Unstable v0.1300.0.0 (February 19th 2021)

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

@@ -1,18 +1,17 @@
 using Microsoft.Xna.Framework;
+using System;
 using System.Collections.Generic;
+using Barotrauma.Items.Components;
+using System.Linq;
 
 namespace Barotrauma
 {
-    public enum AIState { Idle, Attack, Escape, Eat, Flee, Avoid, Aggressive, PassiveAggressive, Protect, Observe, Freeze, Follow }
-
     abstract partial class AIController : ISteerable
     {
         public bool Enabled;
 
         public readonly Character Character;
 
-        private AIState state;
-
         // Update only when the value changes, not when it keeps the same.
         protected AITarget _lastAiTarget;
         // Updated each time the value is updated (also when the value is the same).
@@ -74,25 +73,6 @@ namespace Barotrauma
             get { return true; }
         }
 
-        public virtual AIObjectiveManager ObjectiveManager
-        {
-            get { return null; }
-        }
-
-        public AIState State
-        {
-            get { return state; }
-            set
-            {
-                if (state == value) { return; }
-                PreviousState = state;
-                OnStateChanged(state, value);
-                state = value;
-            }
-        }
-
-        public AIState PreviousState { get; protected set; }
-
         private IEnumerable<Hull> visibleHulls;
         private float hullVisibilityTimer;
         const float hullVisibilityInterval = 0.5f;
@@ -112,6 +92,9 @@ namespace Barotrauma
             }
         }
 
+        protected bool HasValidPath(bool requireNonDirty = false) => 
+            steeringManager is IndoorsSteeringManager pathSteering && pathSteering.CurrentPath != null && !pathSteering.CurrentPath.Finished && !pathSteering.CurrentPath.Unreachable && (!requireNonDirty || !pathSteering.IsPathDirty);
+
         public AIController (Character c)
         {
             Character = c;
@@ -149,8 +132,177 @@ namespace Barotrauma
 
         public void FaceTarget(ISpatialEntity target) => Character.AnimController.TargetDir = target.WorldPosition.X > Character.WorldPosition.X ? Direction.Right : Direction.Left;
 
+        public bool IsSteeringThroughGap { get; protected set; }
+
+        public virtual bool SteerThroughGap(Structure wall, WallSection section, Vector2 targetWorldPos, float deltaTime)
+        {
+            if (wall == null) { return false; }
+            if (section == null) { return false; }
+            Gap gap = section.gap;
+            if (gap == null) { return false; }
+            float maxDistance = Math.Min(wall.Rect.Width, wall.Rect.Height);
+            if (Vector2.DistanceSquared(Character.WorldPosition, targetWorldPos) > maxDistance * maxDistance) { return false; }
+            Hull targetHull = gap.FlowTargetHull;
+            if (targetHull == null) { return false; }
+            if (wall.IsHorizontal)
+            {
+                targetWorldPos.Y = targetHull.WorldRect.Y - targetHull.Rect.Height / 2;
+            }
+            else
+            {
+                targetWorldPos.X = targetHull.WorldRect.Center.X;
+            }
+            return SteerThroughGap(gap, targetWorldPos, deltaTime, maxDistance: -1);
+        }
+
+        public virtual bool SteerThroughGap(Gap gap, Vector2 targetWorldPos, float deltaTime, float maxDistance = -1)
+        {
+            Hull targetHull = gap.FlowTargetHull;
+            if (targetHull == null) { return false; }
+            if (maxDistance > 0)
+            {
+                if (Vector2.DistanceSquared(Character.WorldPosition, targetWorldPos) > maxDistance * maxDistance) { return false; }
+            }
+            if (SteeringManager is IndoorsSteeringManager pathSteering)
+            {
+                pathSteering.ResetPath();
+            }
+            SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(targetWorldPos - Character.WorldPosition));
+            return true;
+        }
+
+        public bool CanPassThroughHole(Structure wall, int sectionIndex, int requiredHoleCount)
+        {
+            if (!wall.SectionBodyDisabled(sectionIndex)) { return false; }
+            int holeCount = 1;
+            for (int j = sectionIndex - 1; j > sectionIndex - requiredHoleCount; j--)
+            {
+                if (wall.SectionBodyDisabled(j))
+                {
+                    holeCount++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            for (int j = sectionIndex + 1; j < sectionIndex + requiredHoleCount; j++)
+            {
+                if (wall.SectionBodyDisabled(j))
+                {
+                    holeCount++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            return holeCount >= requiredHoleCount;
+        }
+
+        protected bool IsWallDisabled(Structure wall)
+        {
+            bool isDisabled = true;
+            for (int i = 0; i < wall.Sections.Length; i++)
+            {
+                if (!wall.SectionBodyDisabled(i))
+                {
+                    isDisabled = false;
+                    break;
+                }
+            }
+            return isDisabled;
+        }
+
+        private readonly HashSet<Item> unequippedItems = new HashSet<Item>();
+        public bool TakeItem(Item item, Inventory targetInventory, bool equip, bool dropOtherIfCannotMove = true, bool allowSwapping = false, bool storeUnequipped = false)
+        {
+            var pickable = item.GetComponent<Pickable>();
+            if (pickable == null) { return false; }
+            if (item.ParentInventory is ItemInventory itemInventory)
+            {
+                if (!itemInventory.Container.HasRequiredItems(Character, addMessage: false)) { return false; }
+            }
+            if (equip)
+            {
+                int targetSlot = -1;
+                //check if all the slots required by the item are free
+                foreach (InvSlotType slots in pickable.AllowedSlots)
+                {
+                    if (slots.HasFlag(InvSlotType.Any)) { continue; }
+                    for (int i = 0; i < targetInventory.Capacity; i++)
+                    {
+                        if (targetInventory is CharacterInventory characterInventory)
+                        {
+                            //slot not needed by the item, continue
+                            if (!slots.HasFlag(characterInventory.SlotTypes[i])) { continue; }
+                        }
+                        targetSlot = i;
+                        //slot free, continue
+                        var otherItem = targetInventory.GetItemAt(i);
+                        if (otherItem == null) { continue; }
+                        //try to move the existing item to LimbSlot.Any and continue if successful
+                        if (otherItem.AllowedSlots.Contains(InvSlotType.Any) && targetInventory.TryPutItem(otherItem, Character, CharacterInventory.anySlot))
+                        {
+                            if (storeUnequipped && targetInventory.Owner == Character)
+                            {
+                                unequippedItems.Add(otherItem);
+                            }
+                            continue;
+                        }
+                        if (dropOtherIfCannotMove)
+                        {
+                            //if everything else fails, simply drop the existing item
+                            otherItem.Drop(Character);
+                        }
+                    }
+                }
+                return targetInventory.TryPutItem(item, targetSlot, allowSwapping, allowCombine: false, Character);
+            }
+            else
+            {
+                return targetInventory.TryPutItem(item, Character, CharacterInventory.anySlot);
+            }
+        }
+
+        public void UnequipEmptyItems(Item item, bool avoidDroppingInSea = true) => UnequipEmptyItems(Character, item, avoidDroppingInSea);
+
+        public static void UnequipEmptyItems(Character character, Item item, bool avoidDroppingInSea = true)
+        {
+            if (item.OwnInventory.AllItems.Any(it => it.Condition <= 0.0f))
+            {
+                foreach (Item containedItem in item.OwnInventory.AllItemsMod)
+                {
+                    if (containedItem == null) { continue; }
+                    if (containedItem.Condition <= 0.0f)
+                    {
+                        if (character.Submarine == null && avoidDroppingInSea)
+                        {
+                            // If we are outside of main sub, try to put the item in the inventory instead dropping it in the sea.
+                            if (character.Inventory.TryPutItem(containedItem, character, CharacterInventory.anySlot))
+                            {
+                                continue;
+                            }
+                        }
+                        containedItem.Drop(character);
+                    }
+                }
+            }
+        }
+
+        public void ReequipUnequipped()
+        {
+            foreach (var item in unequippedItems)
+            {
+                if (item != null && !item.Removed && Character.HasItem(item))
+                {
+                    TakeItem(item, Character.Inventory, equip: true, dropOtherIfCannotMove: true, allowSwapping: true, storeUnequipped: false);
+                }
+            }
+            unequippedItems.Clear();
+        }
+
         protected virtual void OnStateChanged(AIState from, AIState to) { }
         protected virtual void OnTargetChanged(AITarget previousTarget, AITarget newTarget) { }
-
     }
 }

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

@@ -50,9 +50,9 @@ namespace Barotrauma
         /// Returns true if the current or the next node is in ladders.
         /// </summary>
         public bool InLadders =>
-            currentPath != null &&
-            currentPath.CurrentNode != null && (currentPath.CurrentNode.Ladders != null && !currentPath.CurrentNode.Ladders.Item.NonInteractable ||
-            (currentPath.NextNode != null && currentPath.NextNode.Ladders != null && !currentPath.NextNode.Ladders.Item.NonInteractable));
+            currentPath != null && currentPath.CurrentNode != null &&
+            (currentPath.CurrentNode.Ladders != null && currentPath.CurrentNode.Ladders.Item.IsInteractable(character) ||
+             (currentPath.NextNode != null && currentPath.NextNode.Ladders != null && currentPath.NextNode.Ladders.Item.IsInteractable(character)));
 
         /// <summary>
         /// Returns true if any node in the path is in stairs
@@ -70,7 +70,7 @@ namespace Barotrauma
                 if (currentPath.NextNode == null) { return false; }
                 var currentLadder = currentPath.CurrentNode.Ladders;
                 if (currentLadder == null) { return false; }
-                if (currentLadder.Item.NonInteractable) { return false; }
+                if (!currentLadder.Item.IsInteractable(character)) { return false; }
                 var nextLadder = GetNextLadder();
                 return nextLadder != null && nextLadder == currentLadder;
             }
@@ -117,13 +117,13 @@ namespace Barotrauma
         }
 
         /// <summary>
-        /// Seeks the ladder from the current and the next two nodes.
+        /// Seeks the ladder from the next and next + 1 nodes.
         /// </summary>
         public Ladder GetNextLadder()
         {
             if (currentPath == null) { return null; }
             if (currentPath.NextNode == null) { return null; }
-            if (currentPath.NextNode.Ladders != null && !currentPath.NextNode.Ladders.Item.NonInteractable)
+            if (currentPath.NextNode.Ladders != null && currentPath.NextNode.Ladders.Item.IsInteractable(character))
             {
                 return currentPath.NextNode.Ladders;
             }
@@ -134,7 +134,7 @@ namespace Barotrauma
                 {
                     var node = currentPath.Nodes[index];
                     if (node == null) { return null; }
-                    if (node.Ladders != null && !node.Ladders.Item.NonInteractable)
+                    if (node.Ladders != null && node.Ladders.Item.IsInteractable(character))
                     {
                         return node.Ladders;
                     }
@@ -146,7 +146,7 @@ namespace Barotrauma
                         {
                             node = currentPath.Nodes[index];
                             if (node == null) { return null; }
-                            if (node.Ladders != null && !node.Ladders.Item.NonInteractable)
+                            if (node.Ladders != null && node.Ladders.Item.IsInteractable(character))
                             {
                                 return node.Ladders;
                             }
@@ -294,10 +294,16 @@ namespace Barotrauma
             bool isDiving = character.AnimController.InWater && character.AnimController.HeadInWater;
             // Only humanoids can climb ladders
             bool canClimb = character.AnimController is HumanoidAnimController && !character.LockHands;
-            var ladders = GetNextLadder();
+            Ladder currentLadder = currentPath.CurrentNode.Ladders;
+            if (currentLadder != null && !currentLadder.Item.IsInteractable(character))
+            {
+                currentLadder = null;
+            }
+            Ladder nextLadder = GetNextLadder();
+            var ladders = currentLadder ?? nextLadder;
             if (canClimb && !isDiving && ladders != null && character.SelectedConstruction != ladders.Item)
             {
-                if (IsNextNodeLadder || currentPath.CurrentIndex == currentPath.Nodes.Count - 1)
+                if (IsNextNodeLadder || currentPath.Finished)
                 {
                     if (character.CanInteractWith(ladders.Item))
                     {
@@ -325,7 +331,6 @@ namespace Barotrauma
             if (character.IsClimbing && !isDiving)
             {
                 Vector2 diff = currentPath.CurrentNode.SimPosition - pos;
-                Ladder nextLadder = GetNextLadder();
                 bool nextLadderSameAsCurrent = IsNextLadderSameAsCurrent;
                 if (nextLadderSameAsCurrent)
                 {
@@ -341,8 +346,7 @@ namespace Barotrauma
                         diff.Y = Math.Max(diff.Y, 1.0f);
                     }
                     // We need some margin, because if a hatch has closed, it's possible that the height from floor is slightly negative.
-                    float margin = 0.1f;
-                    bool isAboveFloor = heightFromFloor > -margin && heightFromFloor < collider.height * 1.5f;
+                    bool isAboveFloor = heightFromFloor > -0.1f;
                     // If the next waypoint is horizontally far, we don't want to keep holding the ladders
                     if (isAboveFloor && (nextLadder == null || Math.Abs(currentPath.CurrentNode.WorldPosition.X - currentPath.NextNode.WorldPosition.X) > 50))
                     {
@@ -357,7 +361,7 @@ namespace Barotrauma
                             nextLadder.Item.TryInteract(character, false, true);
                         }
                     }
-                    if (nextLadder != null || isAboveFloor)
+                    if (isAboveFloor || nextLadderSameAsCurrent)
                     {
                         currentPath.SkipToNextNode();
                     }
@@ -383,8 +387,7 @@ namespace Barotrauma
                     character.SelectedConstruction = null;
                 }
                 var door = currentPath.CurrentNode.ConnectedDoor;
-                bool blockedByDoor = door != null && !door.IsOpen && !door.IsBroken;
-                if (!blockedByDoor)
+                if (door == null || door.CanBeTraversed)
                 {
                     float multiplier = MathHelper.Lerp(1, 10, MathHelper.Clamp(collider.LinearVelocity.Length() / 10, 0, 1));
                     float targetDistance = collider.GetSize().X * multiplier;
@@ -417,10 +420,9 @@ namespace Barotrauma
                 bool isAboveFeet = currentPath.CurrentNode.SimPosition.Y > colliderBottom.Y;
                 bool isNotTooHigh = currentPath.CurrentNode.SimPosition.Y < colliderBottom.Y + characterHeight;
                 var door = currentPath.CurrentNode.ConnectedDoor;
-                bool blockedByDoor = door != null && !door.IsOpen && !door.IsBroken;
                 float margin = MathHelper.Lerp(1, 10, MathHelper.Clamp(Math.Abs(velocity.X) / 10, 0, 1));
                 float targetDistance = Math.Max(collider.radius * margin, minWidth);
-                if (horizontalDistance < targetDistance && isAboveFeet && isNotTooHigh && !blockedByDoor)
+                if (horizontalDistance < targetDistance && isAboveFeet && isNotTooHigh && (door == null || door.CanBeTraversed))
                 {
                     currentPath.SkipToNextNode();
                 }
@@ -434,18 +436,20 @@ namespace Barotrauma
 
         private bool CanAccessDoor(Door door, Func<Controller, bool> buttonFilter = null)
         {
-            if (door.IsOpen) { return true; }
-            if (door.Item.NonInteractable) { return false; }
-            if (CanBreakDoors) { return true; }
-            if (door.IsStuck || door.IsJammed) { return false; }
-            if (!canOpenDoors || character.LockHands) { return false; }
+            if (door.IsOpen || door.IsBroken) { return true; }
+            if (!door.Item.IsInteractable(character)) { return false; }
+            if (!CanBreakDoors)
+            {
+                if (door.IsStuck || door.IsJammed) { return false; }
+                if (!canOpenDoors || character.LockHands) { return false; }
+            }
             if (door.HasIntegratedButtons)
             {
-                return door.CanBeOpenedWithoutTools(character);
+                return door.HasAccess(character) || CanBreakDoors;
             }
             else
             {
-                return door.Item.GetConnectedComponents<Controller>(true).Any(b => !b.Item.NonInteractable && b.HasAccess(character) && (buttonFilter == null || buttonFilter(b)));
+                return door.Item.GetConnectedComponents<Controller>(true).Any(b => b.HasAccess(character) && (buttonFilter == null || buttonFilter(b))) || CanBreakDoors;
             }
         }
 
@@ -620,18 +624,19 @@ namespace Barotrauma
                 }
             }
 
+            bool nextNodeAboveWaterLevel = nextNode.Waypoint.CurrentHull != null && nextNode.Waypoint.CurrentHull.Surface < nextNode.Waypoint.Position.Y;
             //non-humanoids can't climb up ladders
             if (!(character.AnimController is HumanoidAnimController))
             {
-                if (node.Waypoint.Ladders != null && nextNode.Waypoint.Ladders != null && (nextNode.Waypoint.Ladders.Item.NonInteractable || character.LockHands)||
+                if (node.Waypoint.Ladders != null && nextNode.Waypoint.Ladders != null && (!nextNode.Waypoint.Ladders.Item.IsInteractable(character) || character.LockHands)||
                     (nextNode.Position.Y - node.Position.Y > 1.0f && //more than one sim unit to climb up
-                    nextNode.Waypoint.CurrentHull != null && nextNode.Waypoint.CurrentHull.Surface < nextNode.Waypoint.Position.Y)) //upper node not underwater
+                    nextNodeAboveWaterLevel)) //upper node not underwater
                 {
                     return null;
                 }
             }
 
-            if (node.Waypoint != null && node.Waypoint.CurrentHull != null)
+            if (node.Waypoint.CurrentHull != null)
             {
                 var hull = node.Waypoint.CurrentHull;
                 if (hull.FireSources.Count > 0)
@@ -641,23 +646,26 @@ namespace Barotrauma
                         penalty += fs.Size.X * 10.0f;
                     }
                 }
-                if (character.NeedsAir && hull.WaterVolume / hull.Rect.Width > 100.0f)
+                if (character.NeedsAir)
                 {
-                    if (!HumanAIController.HasDivingSuit(character))
+                    if (hull.WaterVolume / hull.Rect.Width > 100.0f)
                     {
-                        penalty += 500.0f;
+                        if (!HumanAIController.HasDivingSuit(character))
+                        {
+                            penalty += 500.0f;
+                        }
+                    }
+                    if (character.PressureProtection < 10.0f && hull.WaterVolume > hull.Volume)
+                    {
+                        penalty += 1000.0f;
                     }
                 }
-                if (character.PressureProtection < 10.0f && hull.WaterVolume > hull.Volume)
-                {
-                    penalty += 1000.0f;
-                }
-            }
 
-            float yDist = Math.Abs(node.Position.Y - nextNode.Position.Y);
-            if (node.Waypoint.Ladders == null && nextNode.Waypoint.Ladders == null)
-            {
-                penalty += yDist * 10.0f;
+                float yDist = Math.Abs(node.Position.Y - nextNode.Position.Y);
+                if (nextNodeAboveWaterLevel && node.Waypoint.Ladders == null && nextNode.Waypoint.Ladders == null && node.Waypoint.Stairs == null && nextNode.Waypoint.Stairs == null)
+                {
+                    penalty += yDist * 10.0f;
+                }
             }
 
             return penalty;

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

@@ -19,6 +19,7 @@ namespace Barotrauma
         private Body targetBody;
         private Vector2 attachSurfaceNormal;
         private Submarine targetSubmarine;
+        private readonly Character character;
 
         public bool AttachToSub { get; private set; }
         public bool AttachToWalls { get; private set; }
@@ -74,22 +75,24 @@ namespace Barotrauma
                 attachLimb = enemyAI.Character.AnimController.MainLimb;
             }
 
+            character = enemyAI.Character;
             enemyAI.Character.OnDeath += OnCharacterDeath;
         }
 
         public void SetAttachTarget(Structure wall, Vector2 attachPos, Vector2 attachSurfaceNormal)
         {
+            if (wall == null) { return; }
+            var sub = wall.Submarine;
+            if (sub == null) { return; }
             targetWall = wall;
-            targetBody = wall.Submarine.PhysicsBody.FarseerBody;
-            targetSubmarine = wall.Submarine;
+            targetSubmarine = sub;
+            targetBody = targetSubmarine.PhysicsBody.FarseerBody;
             this.attachSurfaceNormal = attachSurfaceNormal;
             wallAttachPos = attachPos;
         }
         
         public void Update(EnemyAIController enemyAI, float deltaTime)
         {
-            Character character = enemyAI.Character;
-
             if (character.Submarine != null)
             {
                 DeattachFromBody(reset: true);
@@ -160,12 +163,12 @@ namespace Barotrauma
                                         {
                                             if (MathUtils.GetLineIntersection(edge.Point1, edge.Point2, character.WorldPosition, cell.Center, out Vector2 intersection))
                                             {
-                                                attachSurfaceNormal = edge.GetNormal(cell);
-                                                targetBody = cell.Body;
                                                 Vector2 potentialAttachPos = ConvertUnits.ToSimUnits(intersection);
-                                                float distSqr = Vector2.DistanceSquared(character.SimPosition, wallAttachPos);
+                                                float distSqr = Vector2.DistanceSquared(character.SimPosition, potentialAttachPos);
                                                 if (distSqr < closestDist)
                                                 {
+                                                    attachSurfaceNormal = edge.GetNormal(cell);
+                                                    targetBody = cell.Body;
                                                     wallAttachPos = potentialAttachPos;
                                                     closestDist = distSqr;
                                                 }
@@ -183,7 +186,7 @@ namespace Barotrauma
                         wallAttachPos = Vector2.Zero;
                     }
 
-                    if (wallAttachPos == Vector2.Zero)
+                    if (wallAttachPos == Vector2.Zero || targetBody == null)
                     {
                         DeattachFromBody(reset: false);
                     }
@@ -194,7 +197,7 @@ namespace Barotrauma
                         if (squaredDistance < targetDistance * targetDistance)
                         {
                             //close enough to a wall -> attach
-                            AttachToBody(character.AnimController.Collider, attachLimb, targetBody, wallAttachPos);
+                            AttachToBody(wallAttachPos);
                             enemyAI.SteeringManager.Reset();
                         }
                         else
@@ -217,7 +220,7 @@ namespace Barotrauma
                             {
                                 if (Vector2.DistanceSquared(ConvertUnits.ToDisplayUnits(transformedAttachPos), enemyAI.AttackingLimb.WorldPosition) < enemyAI.AttackingLimb.attack.DamageRange * enemyAI.AttackingLimb.attack.DamageRange)
                                 {
-                                    AttachToBody(character.AnimController.Collider, attachLimb, targetBody, transformedAttachPos);
+                                    AttachToBody(transformedAttachPos);
                                 }
                             }
                         }
@@ -268,9 +271,12 @@ namespace Barotrauma
             }
         }
 
-        private void AttachToBody(PhysicsBody collider, Limb attachLimb, Body targetBody, Vector2 attachPos)
+        private void AttachToBody(Vector2 attachPos)
         {
+            if (attachLimb == null) { return; }
+            if (targetBody == null) { return; }
             if (attachCooldown > 0) { return; }
+            var collider = character.AnimController.Collider;
             //already attached to something
             if (AttachJoints.Count > 0)
             {

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

@@ -178,7 +178,7 @@ namespace Barotrauma
                 {
                     if (Timing.TotalTime < GameMain.GameSession.RoundStartTime + 120.0f && 
                         speaker?.CurrentHull != null && 
-                        speaker.TeamID == Character.TeamType.FriendlyNPC && 
+                        speaker.TeamID == CharacterTeamType.FriendlyNPC && 
                         Character.CharacterList.Any(c => c.TeamID != speaker.TeamID && c.CurrentHull == speaker.CurrentHull)) 
                     {
                         currentFlags.Add("EnterOutpost"); 
@@ -213,7 +213,7 @@ namespace Barotrauma
                     }
                 }
 
-                if (speaker.TeamID == Character.TeamType.FriendlyNPC && speaker.Submarine != null && speaker.Submarine.Info.IsOutpost)
+                if (speaker.TeamID == CharacterTeamType.FriendlyNPC && speaker.Submarine != null && speaker.Submarine.Info.IsOutpost)
                 {
                     currentFlags.Add("OutpostNPC");
                 }

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

@@ -67,6 +67,12 @@ namespace Barotrauma
                 _abandon = value;
                 if (_abandon)
                 {
+#if DEBUG
+                    if (HumanAIController.debugai && objectiveManager.IsOrder(this) && !objectiveManager.IsCurrentOrder<AIObjectiveGoTo>())
+                    {
+                        throw new Exception("Order abandoned!");
+                    }
+#endif
                     OnAbandon();
                 }
             }
@@ -96,9 +102,21 @@ namespace Barotrauma
             return all;
         }
 
+        /// <summary>
+        /// A single shot event. Automatically cleared after launching. Use OnCompleted method for implementing (internal) persistent behavior.
+        /// </summary>
         public event Action Completed;
+        /// <summary>
+        /// A single shot event. Automatically cleared after launching. Use OnAbandoned method for implementing (internal) persistent behavior.
+        /// </summary>
         public event Action Abandoned;
+        /// <summary>
+        /// A single shot event. Automatically cleared after launching. Use OnSelected method for implementing (internal) persistent behavior.
+        /// </summary>
         public event Action Selected;
+        /// <summary>
+        /// A single shot event. Automatically cleared after launching. Use OnDeselected method for implementing (internal) persistent behavior.
+        /// </summary>
         public event Action Deselected;
 
         protected HumanAIController HumanAIController => character.AIController as HumanAIController;
@@ -202,7 +220,7 @@ namespace Barotrauma
             { 
                 if (!AllowOutsideSubmarine && character.Submarine == null) { return false; }
                 if (AllowInAnySub) { return true; }
-                if (AllowInFriendlySubs && character.Submarine.TeamID == Character.TeamType.FriendlyNPC) { return true; }
+                if (AllowInFriendlySubs && character.Submarine.TeamID == CharacterTeamType.FriendlyNPC) { return true; }
                 return character.Submarine.TeamID == character.TeamID || character.Submarine.DockedTo.Any(sub => sub.TeamID == character.TeamID);
             }
         }
@@ -212,7 +230,7 @@ namespace Barotrauma
         /// </summary>
         public virtual float GetPriority()
         {
-            bool isOrder = objectiveManager.CurrentOrder == this;
+            bool isOrder = objectiveManager.IsOrder(this);
             if (!IsAllowed)
             {
                 Priority = 0;
@@ -221,7 +239,7 @@ namespace Barotrauma
             }
             if (isOrder)
             {
-                Priority = AIObjectiveManager.OrderPriority;
+                Priority = objectiveManager.GetOrderPriority(this);
             }
             else
             {
@@ -243,7 +261,7 @@ namespace Barotrauma
 
         public virtual void Update(float deltaTime)
         {
-            if (objectiveManager.CurrentOrder != this && objectiveManager.WaitTimer <= 0)
+            if (!objectiveManager.IsOrder(this) && objectiveManager.WaitTimer <= 0)
             {
                 UpdateDevotion(deltaTime);
             }
@@ -318,22 +336,26 @@ namespace Barotrauma
         {
             Reset();
             Selected?.Invoke();
+            Selected = null;
         }
 
         public virtual void OnDeselected()
         {
             CumulatedDevotion = 0;
             Deselected?.Invoke();
+            Deselected = null;
         }
 
         protected virtual void OnCompleted()
         {
             Completed?.Invoke();
+            Completed = null;
         }
 
         protected virtual void OnAbandon()
         {
             Abandoned?.Invoke();
+            Abandoned = null;
         }
 
         public virtual void Reset()
@@ -408,7 +430,14 @@ namespace Barotrauma
                     subObjectives.Remove(subObjective);
                     if (AbandonWhenCannotCompleteSubjectives)
                     {
-                        Abandon = true;
+                        if (objectiveManager.IsOrder(this))
+                        {
+                            Reset();
+                        }
+                        else
+                        {
+                            Abandon = true;
+                        }
                     }
                 }
             }

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

@@ -21,7 +21,7 @@ namespace Barotrauma
             if (battery == null) { return false; }
             var item = battery.Item;
             if (item.IgnoreByAI) { return false; }
-            if (item.NonInteractable) { return false; }
+            if (!item.IsInteractable(character)) { return false; }
             if (item.Submarine == null) { return false; }
             if (item.CurrentHull == null) { return false; }
             if (item.Submarine.TeamID != character.TeamID) { return false; }
@@ -64,7 +64,7 @@ namespace Barotrauma
 
         private bool IsReady(PowerContainer battery)
         {
-            if (battery.HasBeenTuned && character.CurrentOrder == null) { return true; }
+            if (battery.HasBeenTuned && character.IsDismissed) { return true; }
             if (Option == "charge")
             {
                 return battery.RechargeRatio >= PowerContainer.aiRechargeTargetRatio;
@@ -79,7 +79,7 @@ namespace Barotrauma
             new AIObjectiveOperateItem(battery, character, objectiveManager, Option, false, priorityModifier: PriorityModifier)
             {
                 IsLoop = false,
-                Override = character.CurrentOrder != null,
+                Override = !character.IsDismissed,
                 completionCondition = () => IsReady(battery)
             };
 

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

@@ -48,7 +48,7 @@ namespace Barotrauma
                 float selectedBonus = isSelected ? 100 - MaxDevotion : 0;
                 float devotion = (CumulatedDevotion + selectedBonus) / 100;
                 float reduction = IsPriority ? 1 : isSelected ? 2 : 3;
-                float max = MathHelper.Min(AIObjectiveManager.OrderPriority - reduction, 90);
+                float max = AIObjectiveManager.LowestOrderPriority - reduction;
                 Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (distanceFactor * PriorityModifier), 0, 1));
             }
             return Priority;
@@ -58,6 +58,11 @@ namespace Barotrauma
         {
             // Only continue when the get item sub objectives have been completed.
             if (subObjectives.Any()) { return; }
+            if (item.IgnoreByAI)
+            {
+                Abandon = true;
+                return;
+            }
             if (HumanAIController.FindSuitableContainer(character, item, ignoredContainers, ref itemIndex, out Item suitableContainer))
             {
                 itemIndex = 0;
@@ -74,6 +79,7 @@ namespace Barotrauma
                     TryAddSubObjective(ref decontainObjective, () => new AIObjectiveDecontainItem(character, item, objectiveManager, targetContainer: suitableContainer.GetComponent<ItemContainer>())
                     {
                         Equip = equip,
+                        TakeWholeStack = true,
                         DropIfFails = true
                     }, 
                     onCompleted: () =>

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

@@ -12,21 +12,30 @@ namespace Barotrauma
         public override bool AllowAutomaticItemUnequipping => false;
         public override bool ForceOrderPriority => false;
 
-        public readonly Item prioritizedItem;
+        public readonly List<Item> prioritizedItems = new List<Item>();
 
-        public AIObjectiveCleanupItems(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1, Item prioritizedItem = null)
+        public AIObjectiveCleanupItems(Character character, AIObjectiveManager objectiveManager, Item prioritizedItem = null, float priorityModifier = 1)
             : base(character, objectiveManager, priorityModifier)
         {
-            this.prioritizedItem = prioritizedItem;
+            if (prioritizedItem != null)
+            {
+                prioritizedItems.Add(prioritizedItem);
+            }
         }
 
-        protected override float TargetEvaluation() => Targets.Any() ? AIObjectiveManager.RunPriority - 1 : 0;
+        public AIObjectiveCleanupItems(Character character, AIObjectiveManager objectiveManager, IEnumerable<Item> prioritizedItems, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            this.prioritizedItems.AddRange(prioritizedItems.Where(i => i != null));
+        }
+
+        protected override float TargetEvaluation() => Targets.Any() ? (objectiveManager.IsOrder(this) ? objectiveManager.GetOrderPriority(this) : AIObjectiveManager.RunPriority - 1) : 0;
 
         protected override bool Filter(Item target)
         {
             // If the target was selected as a valid target, we'll have to accept it so that the objective can be completed.
             // The validity changes when a character picks the item up.
-            if (!IsValidTarget(target, character)) { return Objectives.ContainsKey(target) && IsItemInsideValidSubmarine(target, character); }
+            if (!IsValidTarget(target, character, checkInventory: true)) { return Objectives.ContainsKey(target) && IsItemInsideValidSubmarine(target, character); }
             if (target.CurrentHull.FireSources.Count > 0) { return false; }
             // Don't repair items in rooms that have enemies inside.
             if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))) { return false; }
@@ -38,7 +47,7 @@ namespace Barotrauma
         protected override AIObjective ObjectiveConstructor(Item item)
             => new AIObjectiveCleanupItem(item, character, objectiveManager, priorityModifier: PriorityModifier)
             {
-                IsPriority = prioritizedItem == item
+                IsPriority = prioritizedItems.Contains(item)
             };
 
         protected override void OnObjectiveCompleted(AIObjective objective, Item target)
@@ -56,12 +65,19 @@ namespace Barotrauma
             return true;
         }
 
-        public static bool IsValidTarget(Item item, Character character)
+        public static bool IsValidContainer(Item item, Character character) =>
+            !item.IgnoreByAI && item.IsInteractable(character) && item.HasTag("allowcleanup") && item.ParentInventory == null && item.OwnInventory != null && item.OwnInventory.AllItems.Any() && IsItemInsideValidSubmarine(item, character);
+
+        public static bool IsValidTarget(Item item, Character character, bool checkInventory)
         {
             if (item == null) { return false; }
             if (item.IgnoreByAI) { return false; }
-            if (item.NonInteractable) { return false; }
-            if (item.ParentInventory != null) { return false; }
+            if (!item.IsInteractable(character)) { return false; }
+            if (item.SpawnedInOutpost) { return false; }
+            if (item.ParentInventory != null)
+            {
+                if (item.Container == null || !IsValidContainer(item.Container, character)) { return false; }
+            }
             if (character != null && !IsItemInsideValidSubmarine(item, character)) { return false; }
             var pickable = item.GetComponent<Pickable>();
             if (pickable == null) { return false; }
@@ -83,20 +99,29 @@ namespace Barotrauma
             {
                 return false;
             }
+            if (!checkInventory)
+            {
+                return true;
+            }
             bool canEquip = true;
             if (!item.AllowedSlots.Contains(InvSlotType.Any))
             {
                 canEquip = false;
+                var inv = character.Inventory;
                 foreach (var allowedSlot in item.AllowedSlots)
                 {
-                    int slot = character.Inventory.FindLimbSlot(allowedSlot);
-                    if (slot > -1)
+                    foreach (var slotType in inv.SlotTypes)
                     {
-                        if (character.Inventory.Items[slot] == null)
+                        if (!allowedSlot.HasFlag(slotType)) { continue; }                        
+                        for (int i = 0; i < inv.Capacity; i++)
                         {
                             canEquip = true;
-                            break;
-                        }
+                            if (allowedSlot.HasFlag(inv.SlotTypes[i]) && inv.GetItemAt(i) != null)
+                            {
+                                canEquip = false;
+                                break;
+                            }
+                        }                        
                     }
                 }
             }

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

@@ -79,11 +79,17 @@ namespace Barotrauma
         private float coolDownTimer;
         private IEnumerable<Body> myBodies;
         private float aimTimer;
+        private float spreadTimer;
 
         private bool canSeeTarget;
         private float visibilityCheckTimer;
         private readonly float visibilityCheckInterval = 0.2f;
 
+        private float sqrDistance;
+        private readonly float maxDistance = 2000;
+        private readonly float distanceCheckInterval = 0.2f;
+        private float distanceTimer;
+
         /// <summary>
         /// Aborts the objective when this condition is true
         /// </summary>
@@ -108,9 +114,13 @@ namespace Barotrauma
         public CombatMode Mode { get; private set; }
 
         private bool IsOffensiveOrArrest => initialMode == CombatMode.Offensive || initialMode == CombatMode.Arrest;
-        private bool TargetEliminated => Enemy == null || Enemy.Removed || Enemy.IsUnconscious;
+        private bool TargetEliminated => IsEnemyDisabled || Enemy.IsUnconscious;
         private bool IsEnemyDisabled => Enemy == null || Enemy.Removed || Enemy.IsDead;
-        private bool EnemyIsClose() => Enemy != null && character.CurrentHull == Enemy.CurrentHull || Vector2.DistanceSquared(character.Position, Enemy.Position) < 500;
+
+        private float AimSpeed => HumanAIController.AimSpeed;
+        private float AimAccuracy => HumanAIController.AimAccuracy;
+
+        private bool EnemyIsClose() => Enemy != null && character.CurrentHull != null && character.CurrentHull == Enemy.CurrentHull || Vector2.DistanceSquared(character.Position, Enemy.Position) < 500;
 
         public AIObjectiveCombat(Character character, Character enemy, CombatMode mode, AIObjectiveManager objectiveManager, float priorityModifier = 1, float coolDown = 10.0f) 
             : base(character, objectiveManager, priorityModifier)
@@ -136,11 +146,12 @@ namespace Barotrauma
             {
                 Mode = CombatMode.Retreat;
             }
+            spreadTimer = Rand.Range(-10, 10);
         }
 
         public override float GetPriority()
         {
-            if (character.TeamID == Character.TeamType.FriendlyNPC && Enemy != null)
+            if (character.TeamID == CharacterTeamType.FriendlyNPC && Enemy != null)
             {
                 if (Enemy.Submarine == null || (Enemy.Submarine.TeamID != character.TeamID && Enemy.Submarine != character.Submarine))
                 {
@@ -168,6 +179,12 @@ namespace Barotrauma
             {
                 findSafety.Priority = 0;
             }
+            distanceTimer -= deltaTime;
+            if (distanceTimer < 0)
+            {
+                distanceTimer = distanceCheckInterval;
+                sqrDistance = Vector2.DistanceSquared(character.WorldPosition, Enemy.WorldPosition);
+            }
         }
 
         protected override bool Check()
@@ -175,9 +192,13 @@ namespace Barotrauma
             if (IsOffensiveOrArrest && Mode != initialMode)
             {
                 Abandon = true;
-                SteeringManager.Reset();
                 return false;
             }
+            if (sqrDistance > maxDistance * maxDistance)
+            {
+                // The target escaped from us.
+                return true;
+            }
             return IsEnemyDisabled || (!IsOffensiveOrArrest && coolDownTimer <= 0);
         }
 
@@ -186,7 +207,6 @@ namespace Barotrauma
             if (abortCondition != null && abortCondition())
             {
                 Abandon = true;
-                SteeringManager.Reset();
                 return;
             }
             if (!IsOffensiveOrArrest)
@@ -238,7 +258,9 @@ namespace Barotrauma
             }
         }
 
-        private bool IsLoaded(ItemComponent weapon) => weapon.HasRequiredContainedItems(character, addMessage: false);
+        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()
         {
@@ -260,21 +282,21 @@ namespace Barotrauma
                         // No weapons
                         break;
                     }
-                    if (!character.Inventory.Items.Contains(Weapon) || WeaponComponent == null)
+                    if (!character.Inventory.Contains(Weapon) || WeaponComponent == null)
                     {
                         // Not in the inventory anymore or cannot find the weapon component
                         allWeapons.Remove(WeaponComponent);
                         Weapon = null;
                         continue;
                     }
-                    if (IsLoaded(WeaponComponent))
+                    if (IsLoaded(WeaponComponent, checkContainedItems: true))
                     {
                         // All good, the weapon is loaded
                         break;
                     }
                     if (Reload(seekAmmo: false))
                     {
-                        // All good, reloading successful
+                        // All good, we can use the weapon.
                         break;
                     }
                     else
@@ -304,7 +326,7 @@ namespace Barotrauma
                         }
                     }
                 }
-                bool isAllowedToSeekWeapons = !EnemyIsClose() && character.TeamID != Character.TeamType.FriendlyNPC && IsOffensiveOrArrest;
+                bool isAllowedToSeekWeapons = !EnemyIsClose() && character.TeamID != CharacterTeamType.FriendlyNPC && IsOffensiveOrArrest;
                 if (!isAllowedToSeekWeapons)
                 {
                     if (WeaponComponent == null)
@@ -369,7 +391,7 @@ namespace Barotrauma
 
             bool CheckWeapon(bool seekAmmo)
             {
-                if (!character.Inventory.Items.Contains(Weapon) || WeaponComponent == null)
+                if (!character.Inventory.Contains(Weapon) || WeaponComponent == null)
                 {
                     // Not in the inventory anymore or cannot find the weapon component
                     return false;
@@ -564,21 +586,20 @@ namespace Barotrauma
                     container.ContainableItems.Any(containable => containable.Identifiers.Any(id => id.Equals(mobileBatteryTag))));
                 // If there's no such container, assume that the melee weapon can stun without a battery.
                 return containers.None() || containers.Any(container =>
-                    (container as ItemContainer)?.Inventory.Items.Any(i => i != null && i.HasTag(mobileBatteryTag) && i.Condition > 0.0f) ?? false);
+                    (container as ItemContainer)?.Inventory.AllItems.Any(i => i != null && i.HasTag(mobileBatteryTag) && i.Condition > 0.0f) ?? false);
             }
         }
 
         private HashSet<ItemComponent> FindWeaponsFromInventory()
         {
             weapons.Clear();
-            foreach (var item in character.Inventory.Items)
+            foreach (var item in character.Inventory.AllItems)
             {
-                if (item == null) { continue; }
                 if (ignoredWeapons.Contains(item)) { continue; }
                 GetWeapons(item, weapons);
                 if (item.OwnInventory != null)
                 {
-                    item.OwnInventory.Items.ForEach(i => GetWeapons(i, weapons));
+                    item.OwnInventory.AllItems.ForEach(i => GetWeapons(i, weapons));
                 }
             }
             return weapons;
@@ -598,7 +619,7 @@ namespace Barotrauma
 
         private void Unequip()
         {
-            if (!character.LockHands && character.SelectedItems.Contains(Weapon))
+            if (!character.LockHands && character.HeldItems.Contains(Weapon))
             {
                 if (!Weapon.AllowedSlots.Contains(InvSlotType.Any) || !character.Inventory.TryPutItem(Weapon, character, new List<InvSlotType>() { InvSlotType.Any }))
                 {
@@ -617,10 +638,10 @@ namespace Barotrauma
             if (!character.HasEquippedItem(Weapon))
             {
                 Weapon.TryInteract(character, forceSelectKey: true);
-                var slots = Weapon.AllowedSlots.FindAll(s => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand));
+                var slots = Weapon.AllowedSlots.Where(s => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand));
                 if (character.Inventory.TryPutItem(Weapon, character, slots))
                 {
-                    aimTimer = Rand.Range(0.5f, 1f);
+                    aimTimer = Rand.Range(1f, 1.5f) / AimSpeed;
                 }
                 else
                 {
@@ -651,7 +672,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    retreatTarget = findSafety.FindBestHull(HumanAIController.VisibleHulls, allowChangingTheSubmarine: character.TeamID != Character.TeamType.FriendlyNPC);
+                    retreatTarget = findSafety.FindBestHull(HumanAIController.VisibleHulls, allowChangingTheSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
                     findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
                 }
             }
@@ -705,11 +726,7 @@ namespace Barotrauma
                     DialogueIdentifier = "dialogcannotreachtarget",
                     TargetName = Enemy.DisplayName
                 },
-                onAbandon: () =>
-                {
-                    Abandon = true;
-                    SteeringManager.Reset();
-                });
+                onAbandon: () => Abandon = true);
             if (followTargetObjective == null) { return; }
             if (Mode == CombatMode.Arrest && Enemy.Stun > 2)
             {
@@ -724,7 +741,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    if (character.TeamID == Character.TeamType.FriendlyNPC)
+                    if (character.TeamID == CharacterTeamType.FriendlyNPC)
                     {
                         ItemPrefab prefab = ItemPrefab.Find(null, "handcuffs");
                         if (prefab != null)
@@ -769,9 +786,9 @@ namespace Barotrauma
 #endif
                 }
                 // Confiscate stolen goods.
-                foreach (var item in Enemy.Inventory.Items)
+                foreach (var item in Enemy.Inventory.AllItemsMod)
                 {
-                    if (item == null || item == handCuffs) { continue; }
+                    if (item == handCuffs) { continue; }
                     if (item.StolenDuringRound)
                     {
                         item.Drop(character);
@@ -814,33 +831,32 @@ namespace Barotrauma
         /// </summary>
         private bool Reload(bool seekAmmo)
         {
-            if (WeaponComponent == null) { return false; }
-            if (!WeaponComponent.requiredItems.ContainsKey(RelatedItem.RelationType.Contained)) { return false; }
-            var containedItems = Weapon.OwnInventory?.Items;
-            if (containedItems == null) { return true; }
-            // Drop empty ammo
-            foreach (Item containedItem in containedItems)
-            {
-                if (containedItem == null) { continue; }
-                if (containedItem.Condition <= 0)
-                {
-                    containedItem.Drop(character);
-                }
-            }
+            if (WeaponComponent == null) { return false; }        
+            if (Weapon.OwnInventory == null) { return true; }
+            // Eject empty ammo
+            HumanAIController.UnequipEmptyItems(Weapon);
             RelatedItem item = null;
             Item ammunition = null;
             string[] ammunitionIdentifiers = null;
-            foreach (RelatedItem requiredItem in WeaponComponent.requiredItems[RelatedItem.RelationType.Contained])
+            if (WeaponComponent.requiredItems.ContainsKey(RelatedItem.RelationType.Contained))
             {
-                ammunition = containedItems.FirstOrDefault(it => it != null && it.Condition > 0 && requiredItem.MatchesItem(it));
-                if (ammunition != null)
+                foreach (RelatedItem requiredItem in WeaponComponent.requiredItems[RelatedItem.RelationType.Contained])
                 {
-                    // Ammunition still remaining
-                    return true;
+                    ammunition = Weapon.OwnInventory.AllItems.FirstOrDefault(it => it.Condition > 0 && requiredItem.MatchesItem(it));
+                    if (ammunition != null)
+                    {
+                        // Ammunition still remaining
+                        return true;
+                    }
+                    item = requiredItem;
+                    ammunitionIdentifiers = requiredItem.Identifiers;
                 }
-                item = requiredItem;
-                ammunitionIdentifiers = requiredItem.Identifiers;
             }
+            else if (WeaponComponent is MeleeWeapon meleeWeapon)
+            {
+                ammunitionIdentifiers = meleeWeapon.PreferredContainedItems;
+            }
+
             // No ammo
             if (ammunition == null)
             {
@@ -851,22 +867,13 @@ namespace Barotrauma
                     if (ammunition != null)
                     {
                         var container = Weapon.GetComponent<ItemContainer>();
-                        if (container.Item.ParentInventory == character.Inventory)
+                        if (!container.Inventory.TryPutItem(ammunition, null))
                         {
-                            if (!container.Inventory.CanBePut(ammunition))
-                            {
-                                return false;
-                            }
-                            character.Inventory.RemoveItem(ammunition);
-                            if (!container.Inventory.TryPutItem(ammunition, null))
+                            if (ammunition.ParentInventory == character.Inventory)
                             {
                                 ammunition.Drop(character);
                             }
                         }
-                        else
-                        {
-                            container.Combine(ammunition, character);
-                        }
                     }
                 }
             }
@@ -884,6 +891,15 @@ namespace Barotrauma
         private void Attack(float deltaTime)
         {
             character.CursorPosition = Enemy.WorldPosition;
+            if (AimAccuracy < 1)
+            {
+                spreadTimer += deltaTime * Rand.Range(0.01f, 1f);
+                float shake = Rand.Range(0.95f, 1.05f);
+                float offsetAmount = (1 - AimAccuracy) * Rand.Range(300f, 500f);
+                float distanceFactor = MathUtils.InverseLerp(0, 1000 * 1000, sqrDistance);
+                float offset = (float)Math.Sin(spreadTimer * shake) * offsetAmount * distanceFactor;
+                character.CursorPosition += new Vector2(0, offset);
+            }
             if (character.Submarine != null)
             {
                 character.CursorPosition -= character.Submarine.Position;
@@ -894,7 +910,11 @@ namespace Barotrauma
                 canSeeTarget = character.CanSeeTarget(Enemy);
                 visibilityCheckTimer = visibilityCheckInterval;
             }
-            if (!canSeeTarget) { return; }
+            if (!canSeeTarget)
+            {
+                aimTimer = Rand.Range(0.2f, 1f) / AimSpeed;
+                return;
+            }
             if (Weapon.RequireAimToUse)
             {
                 character.SetInput(InputType.Aim, false, true);
@@ -945,14 +965,12 @@ namespace Barotrauma
                 }
                 if (closeEnough)
                 {
-                    SteeringManager.Reset();
-                    character.SetInput(InputType.Shoot, false, true);
-                    Weapon.Use(deltaTime, character);
+                    UseWeapon(deltaTime);
                 }
                 else if (!character.IsFacing(Enemy.WorldPosition))
                 {
                     // Don't do the facing check if we are close to the target, because it easily causes the character to get stuck here when it flips around.
-                    aimTimer = Rand.Range(1f, 1.5f);
+                    aimTimer = Rand.Range(1f, 1.5f) / AimSpeed;
                 }
             }
             else
@@ -961,14 +979,15 @@ namespace Barotrauma
                 {
                     if (sqrDist > repairTool.Range * repairTool.Range) { return; }
                 }
-                if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - Weapon.Position) < MathHelper.PiOver4)
+                float aimFactor = MathHelper.PiOver2 * (1 - AimAccuracy);
+                if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - Weapon.Position) < MathHelper.PiOver4 + aimFactor)
                 {
                     if (myBodies == null)
                     {
                         myBodies = character.AnimController.Limbs.Select(l => l.body.FarseerBody);
                     }
                     var collisionCategories = Physics.CollisionCharacter | Physics.CollisionWall | Physics.CollisionLevel;
-                    var pickedBody = Submarine.PickBody(Weapon.SimPosition, Enemy.SimPosition, myBodies, collisionCategories);
+                    var pickedBody = Submarine.PickBody(Weapon.SimPosition, Enemy.SimPosition, myBodies, collisionCategories, allowInsideFixture: true);
                     if (pickedBody != null)
                     {
                         Character target = null;
@@ -982,24 +1001,29 @@ namespace Barotrauma
                         }
                         if (target != null && (target == Enemy || !HumanAIController.IsFriendly(target)))
                         {
-                            character.SetInput(InputType.Shoot, false, true);
-                            Weapon.Use(deltaTime, character);
-                            float reloadTime = 0;
-                            if (WeaponComponent is RangedWeapon rangedWeapon)
-                            {
-                                reloadTime = rangedWeapon.Reload;
-                            }
-                            if (WeaponComponent is MeleeWeapon mw)
-                            {
-                                reloadTime = mw.Reload;
-                            }
-                            aimTimer = reloadTime * Rand.Range(1f, 1.5f);
+                            UseWeapon(deltaTime);
                         }
                     }
                 }
             }
         }
 
+        private void UseWeapon(float deltaTime)
+        {
+            character.SetInput(InputType.Shoot, false, true);
+            Weapon.Use(deltaTime, character);
+            float reloadTime = 0;
+            if (WeaponComponent is RangedWeapon rangedWeapon)
+            {
+                reloadTime = rangedWeapon.Reload;
+            }
+            if (WeaponComponent is MeleeWeapon mw)
+            {
+                reloadTime = mw.Reload;
+            }
+            aimTimer = Math.Max(reloadTime, reloadTime * Rand.Range(1f, 1.5f) / AimSpeed);
+        }
+
         protected override void OnCompleted()
         {
             base.OnCompleted();
@@ -1007,6 +1031,23 @@ namespace Barotrauma
             {
                 Unequip();
             }
+            if (!HoldPosition)
+            {
+                SteeringManager.Reset();
+            }
+        }
+
+        protected override void OnAbandon()
+        {
+            base.OnAbandon();
+            if (Weapon != null)
+            {
+                Unequip();
+            }
+            if (!HoldPosition)
+            {
+                SteeringManager.Reset();
+            }
         }
 
         public override void Reset()

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

@@ -21,7 +21,8 @@ namespace Barotrauma
         //can either be a tag or an identifier
         public readonly string[] itemIdentifiers;
         public readonly ItemContainer container;
-        public readonly Item item;
+        private readonly Item item;
+        public Item ItemToContain { get; private set; }
 
         private AIObjectiveGetItem getItemObjective;
         private AIObjectiveGoTo goToObjective;
@@ -30,10 +31,13 @@ namespace Barotrauma
 
         public bool AllowToFindDivingGear { get; set; } = true;
         public bool AllowDangerousPressure { get; set; }
-        public float ConditionLevel { get; set; }
+        public float ConditionLevel { get; set; } = 1;
         public bool Equip { get; set; }
         public bool RemoveEmpty { get; set; } = true;
 
+        public bool MoveWholeStack { get; set; }
+
+
         public AIObjectiveContainItem(Character character, Item item, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1)
             : base(character, objectiveManager, priorityModifier)
         {
@@ -66,14 +70,14 @@ namespace Barotrauma
             }
             if (item != null)
             {
-                return container.Inventory.Items.Contains(item);
+                return container.Inventory.Contains(item);
             }
             else
             {
                 int containedItemCount = 0;
-                foreach (Item i in container.Inventory.Items)
+                foreach (Item it in container.Inventory.AllItems)
                 {
-                    if (i != null && CheckItem(i))
+                    if (CheckItem(it))
                     {
                         containedItemCount++;
                     }
@@ -82,7 +86,7 @@ namespace Barotrauma
             }
         }
 
-        private bool CheckItem(Item i) => itemIdentifiers.Any(id => i.Prefab.Identifier == id || i.HasTag(id)) && i.ConditionPercentage > ConditionLevel;
+        private bool CheckItem(Item i) => itemIdentifiers.Any(id => i.Prefab.Identifier == id || i.HasTag(id)) && i.ConditionPercentage >= ConditionLevel && !i.IsThisOrAnyContainerIgnoredByAI();
 
         protected override void Act(float deltaTime)
         {
@@ -91,58 +95,44 @@ namespace Barotrauma
                 Abandon = true;
                 return;
             }
-            Item itemToContain = item ?? character.Inventory.FindItem(i => CheckItem(i) && i.Container != container.Item, recursive: true);
-            if (itemToContain != null)
+            ItemToContain = item ?? character.Inventory.FindItem(i => CheckItem(i) && i.Container != container.Item, recursive: true);
+            if (ItemToContain != null)
             {
-                if (!character.CanInteractWith(itemToContain))
+                if (!character.CanInteractWith(ItemToContain, checkLinked: false))
                 {
                     Abandon = true;
                     return;
                 }
-                if (character.CanInteractWith(container.Item, out _, checkLinked: false))
+                if (character.CanInteractWith(container.Item, checkLinked: false))
                 {
                     if (RemoveEmpty)
                     {
-                        foreach (var emptyItem in container.Inventory.Items)
-                        {
-                            if (emptyItem == null) { continue; }
-                            if (emptyItem.Condition <= 0)
-                            {
-                                emptyItem.Drop(character);
-                            }
-                        }
+                        HumanAIController.UnequipEmptyItems(container.Item);
                     }
-                    // Contain the item
-                    if (itemToContain.ParentInventory == character.Inventory)
+                    Inventory originalInventory = ItemToContain.ParentInventory;
+                    var slots = originalInventory?.FindIndices(ItemToContain);
+                    if (container.Inventory.TryPutItem(ItemToContain, null))
                     {
-                        if (!container.Inventory.CanBePut(itemToContain))
+                        if (MoveWholeStack && slots != null)
                         {
-                            Abandon = true;
-                        }
-                        else
-                        {
-                            character.Inventory.RemoveItem(itemToContain);
-                            if (container.Inventory.TryPutItem(itemToContain, null))
+                            foreach (int slot in slots)
                             {
-                                IsCompleted = true;
-                            }
-                            else
-                            {
-                                itemToContain.Drop(character);
-                                Abandon = true;
+                                foreach (Item item in originalInventory.GetItemsAt(slot).ToList())
+                                {
+                                    container.Inventory.TryPutItem(item, null);
+                                }
                             }
+
+                            IsCompleted = true;
                         }
                     }
                     else
                     {
-                        if (container.Combine(itemToContain, character))
+                        if (ItemToContain.ParentInventory == character.Inventory)
                         {
-                            IsCompleted = true;
-                        }
-                        else
-                        {
-                            Abandon = true;
+                            ItemToContain.Drop(character);
                         }
+                        Abandon = true;
                     }
                 }
                 else
@@ -151,7 +141,7 @@ namespace Barotrauma
                     {
                         DialogueIdentifier = "dialogcannotreachtarget",
                         TargetName = container.Item.Name,
-                        abortCondition = () => !itemToContain.IsOwnedBy(character)
+                        abortCondition = obj => !ItemToContain.IsOwnedBy(character)
                     },
                     onAbandon: () => Abandon = true,
                     onCompleted: () => RemoveSubObjective(ref goToObjective));

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

@@ -22,8 +22,13 @@ namespace Barotrauma
         public AIObjectiveGetItem GetItemObjective => getItemObjective;
         public AIObjectiveContainItem ContainObjective => containObjective;
 
+        public Item TargetItem => targetItem;
+        public ItemContainer TargetContainer => targetContainer;
+
         public bool Equip { get; set; }
 
+        public bool TakeWholeStack { get; set; }
+
         /// <summary>
         /// If true drops the item when containing the item fails.
         /// In both cases abandons the objective.
@@ -58,12 +63,17 @@ namespace Barotrauma
 
         protected override void Act(float deltaTime)
         {
-            Item itemToDecontain = targetItem ?? sourceContainer.Inventory.FindItem(i => itemIdentifiers.Any(id => i.Prefab.Identifier == id || i.HasTag(id)), recursive: false);
+            Item itemToDecontain = targetItem ?? sourceContainer.Inventory.FindItem(i => itemIdentifiers.Any(id => i.Prefab.Identifier == id || i.HasTag(id) && !i.IgnoreByAI), recursive: false);
             if (itemToDecontain == null)
             {
                 Abandon = true;
                 return;
             }
+            if (itemToDecontain.IgnoreByAI)
+            {
+                Abandon = true;
+                return;
+            }
             if (targetContainer == null)
             {
                 if (sourceContainer == null)
@@ -77,7 +87,7 @@ namespace Barotrauma
                     return;
                 }
             }
-            else if (targetContainer.Inventory.Items.Contains(itemToDecontain))
+            else if (targetContainer.Inventory.Contains(itemToDecontain))
             {
                 IsCompleted = true;
                 return;
@@ -85,7 +95,7 @@ namespace Barotrauma
             if (getItemObjective == null && !itemToDecontain.IsOwnedBy(character))
             {
                 TryAddSubObjective(ref getItemObjective,
-                    constructor: () => new AIObjectiveGetItem(character, targetItem, objectiveManager, Equip),
+                    constructor: () => new AIObjectiveGetItem(character, targetItem, objectiveManager, Equip) { TakeWholeStack = this.TakeWholeStack },
                     onAbandon: () => Abandon = true);
                 return;
             }
@@ -94,6 +104,7 @@ namespace Barotrauma
                 TryAddSubObjective(ref containObjective,
                     constructor: () => new AIObjectiveContainItem(character, itemToDecontain, targetContainer, objectiveManager)
                     {
+                        MoveWholeStack = TakeWholeStack,
                         Equip = Equip,
                         RemoveEmpty = false,
                         GetItemPriority = GetItemPriority,

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

@@ -35,7 +35,7 @@ namespace Barotrauma
                 Abandon = true;
                 return Priority;
             }
-            bool isOrder = objectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>();
+            bool isOrder = objectiveManager.HasOrder<AIObjectiveExtinguishFires>();
             if (!isOrder && Character.CharacterList.Any(c => c.CurrentHull == targetHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
             {
                 // Don't go into rooms with any enemies, unless it's an order
@@ -78,14 +78,17 @@ namespace Barotrauma
             {
                 TryAddSubObjective(ref getExtinguisherObjective, () =>
                 {
-                    character.Speak(TextManager.Get("DialogFindExtinguisher"), null, 2.0f, "findextinguisher", 30.0f);
+                    if (character.IsOnPlayerTeam && !character.HasEquippedItem("fireextinguisher", allowBroken: false))
+                    {
+                        character.Speak(TextManager.Get("DialogFindExtinguisher"), null, 2.0f, "findextinguisher", 30.0f);
+                    }
                     var getItemObjective = new AIObjectiveGetItem(character, "fireextinguisher", objectiveManager, equip: true)
                     {
                         AllowStealing = true,
                         // If the item is inside an unsafe hull, decrease the priority
                         GetItemPriority = i => HumanAIController.UnsafeHulls.Contains(i.CurrentHull) ? 0.1f : 1
                     };
-                    if (objectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>())
+                    if (objectiveManager.HasOrder<AIObjectiveExtinguishFires>())
                     {
                         getItemObjective.Abandoned += () => character.Speak(TextManager.Get("dialogcannotfindfireextinguisher"), null, 0.0f, "dialogcannotfindfireextinguisher", 10.0f);
                     };
@@ -105,9 +108,13 @@ namespace Barotrauma
                 }
                 foreach (FireSource fs in targetHull.FireSources)
                 {
-                    bool inRange = fs.IsInDamageRange(character, MathHelper.Clamp(fs.DamageRange * 1.5f, extinguisher.Range * 0.5f, extinguisher.Range));
-                    bool move = !inRange || !HumanAIController.VisibleHulls.Contains(fs.Hull);
-                    if (inRange || useExtinquisherTimer > 0.0f)
+                    float xDist = Math.Abs(character.WorldPosition.X - fs.WorldPosition.X) - fs.DamageRange;
+                    float yDist = Math.Abs(character.WorldPosition.Y - fs.WorldPosition.Y);
+                    bool inRange = xDist + yDist < extinguisher.Range;
+                    // Use the hull position, because the fire x pos is sometimes inside a wall -> the bot can't ever see it and continues running towards the wall.
+                    ISpatialEntity lookTarget = character.CurrentHull == targetHull || character.CurrentHull.linkedTo.Contains(targetHull) ? targetHull : fs as ISpatialEntity;
+                    bool move = !inRange || !character.CanSeeTarget(lookTarget);
+                    if ((inRange && character.CanSeeTarget(lookTarget)) || useExtinquisherTimer > 0)
                     {
                         useExtinquisherTimer += deltaTime;
                         if (useExtinquisherTimer > 2.0f)
@@ -121,19 +128,7 @@ namespace Barotrauma
                         character.CursorPosition += VectorExtensions.Forward(extinguisherItem.body.TransformedRotation + (float)Math.Sin(sinTime) / 2, dist / 2);
                         if (extinguisherItem.RequireAimToUse)
                         {
-                            bool isOperatingButtons = false;
-                            if (SteeringManager == PathSteering)
-                            {
-                                var door = PathSteering.CurrentPath?.CurrentNode?.ConnectedDoor;
-                                if (door != null && !door.IsOpen && !door.IsBroken)
-                                {
-                                    isOperatingButtons = door.HasIntegratedButtons || door.Item.GetConnectedComponents<Controller>(true).Any();
-                                }
-                            }
-                            if (!isOperatingButtons)
-                            {
-                                character.SetInput(InputType.Aim, false, true);
-                            }
+                            character.SetInput(InputType.Aim, false, true);
                             sinTime += deltaTime * 10;
                         }
                         character.SetInput(extinguisherItem.IsShootable ? InputType.Shoot : InputType.Use, false, true);
@@ -142,15 +137,11 @@ namespace Barotrauma
                         {
                             character.Speak(TextManager.GetWithVariable("DialogPutOutFire", "[roomname]", targetHull.DisplayName, true), null, 0, "putoutfire", 10.0f);
                         }
-                        if (!character.CanSeeTarget(fs))
-                        {
-                            move = true;
-                        }
                     }
                     if (move)
                     {
                         //go to the first firesource
-                        if (TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(fs, character, objectiveManager, closeEnough: extinguisher.Range / 2)
+                        if (TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(fs, character, objectiveManager, closeEnough: Math.Max(fs.DamageRange, extinguisher.Range * 0.7f))
                             {
                                 DialogueIdentifier = "dialogcannotreachfire",
                                 TargetName = fs.Hull.DisplayName
@@ -158,7 +149,7 @@ namespace Barotrauma
                                 onAbandon: () =>  Abandon = true, 
                                 onCompleted: () => RemoveSubObjective(ref gotoObjective)))
                         {
-                            gotoObjective.requiredCondition = () => HumanAIController.VisibleHulls.Contains(fs.Hull);
+                            gotoObjective.requiredCondition = () => targetHull == null || character.CanSeeTarget(targetHull);
                         }
                     }
                     else

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

@@ -38,11 +38,19 @@ namespace Barotrauma
         public static bool IsValidTarget(Hull hull, Character character)
         {
             if (hull == null) { return false; }
-            if (hull.IgnoreByAI) { return false; }
             if (hull.FireSources.None()) { return false; }
             if (hull.Submarine == null) { return false; }
             if (character.Submarine == null) { return false; }
             if (!character.Submarine.IsEntityFoundOnThisSub(hull, includingConnectedSubs: true)) { return false; }
+            if (hull.BallastFlora != null) { return false; }
+            foreach (var ballastFlora in MapCreatures.Behavior.BallastFloraBehavior.EntityList)
+            {
+                if (ballastFlora.Parent?.Submarine != character.Submarine) { continue; }
+                if (ballastFlora.Branches.Any(b => !b.Removed && b.Health > 0 && b.CurrentHull == hull))
+                {
+                    return false;
+                }
+            }
             return true;
         }
     }

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

@@ -26,7 +26,7 @@ namespace Barotrauma
         protected override AIObjective ObjectiveConstructor(Character target)
         {
             var combatObjective = new AIObjectiveCombat(character, target, AIObjectiveCombat.CombatMode.Offensive, objectiveManager, PriorityModifier);
-            if (character.TeamID == Character.TeamType.FriendlyNPC && target.TeamID == Character.TeamType.Team1 && GameMain.GameSession?.GameMode is CampaignMode campaign)
+            if (character.TeamID == CharacterTeamType.FriendlyNPC && target.TeamID == CharacterTeamType.Team1 && GameMain.GameSession?.GameMode is CampaignMode campaign)
             {
                 var reputation = campaign.Map?.CurrentLocation?.Reputation;
                 if (reputation != null && reputation.NormalizedValue < Reputation.HostileThreshold)
@@ -50,14 +50,11 @@ namespace Barotrauma
         {
             if (target == null || target.IsDead || target.Removed) { return false; }
             if (target == character) { return false; }
-            if (HumanAIController.IsFriendly(character, target)) { return false; }
             if (target.Submarine == null) { return false; }
-            if (target.Submarine.TeamID != character.TeamID) { return false; }
+            if (character.Submarine == null) { return false; }
             if (target.CurrentHull == null) { return false; }
-            if (character.Submarine != null)
-            {
-                if (!character.Submarine.IsConnectedTo(target.Submarine)) { return false; }
-            }
+            if (HumanAIController.IsFriendly(character, target)) { return false; }
+            if (!character.Submarine.IsConnectedTo(target.Submarine)) { return false; }
             return true;
         }
     }

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

@@ -1,5 +1,7 @@
 using Barotrauma.Items.Components;
 using Barotrauma.Extensions;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Barotrauma
 {
@@ -36,11 +38,11 @@ namespace Barotrauma
                 return;
             }
             targetItem = character.Inventory.FindItemByTag(gearTag, true);
-            if (targetItem == null || !character.HasEquippedItem(targetItem))
+            if (targetItem == null || !character.HasEquippedItem(targetItem) && targetItem.ContainedItems.Any(i => i.HasTag(OXYGEN_SOURCE) && i.Condition > 0))
             {
                 TryAddSubObjective(ref getDivingGear, () =>
                 {
-                    if (targetItem == null)
+                    if (targetItem == null && character.IsOnPlayerTeam)
                     {
                         character.Speak(TextManager.Get("DialogGetDivingGear"), null, 0.0f, "getdivinggear", 30.0f);
                     }
@@ -56,7 +58,7 @@ namespace Barotrauma
             }
             else
             {
-                if (!DropEmptyTanks(character, targetItem, out Item[] containedItems))
+                if (!EjectEmptyTanks(character, targetItem, out var containedItems))
                 {
 #if DEBUG
                     DebugConsole.ThrowError($"{character.Name}: AIObjectiveFindDivingGear failed - the item \"" + targetItem + "\" has no proper inventory");
@@ -64,14 +66,25 @@ namespace Barotrauma
                     Abandon = true;
                     return;
                 }
-                if (containedItems.None(it => it != null && it.HasTag(OXYGEN_SOURCE) && it.Condition > MIN_OXYGEN))
+                float min = character.Submarine == null ? 0.01f : MIN_OXYGEN;
+                if (containedItems.None(it => it != null && it.HasTag(OXYGEN_SOURCE) && it.Condition > min))
                 {
                     // No valid oxygen source loaded.
-                    // Seek oxygen that has min 10% condition left.
+                    // Seek oxygen that has at least 10% condition left.
                     TryAddSubObjective(ref getOxygen, () =>
                     {
-                        character.Speak(TextManager.Get("DialogGetOxygenTank"), null, 0, "getoxygentank", 30.0f);
-                        return new AIObjectiveContainItem(character, OXYGEN_SOURCE, targetItem.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC)
+                        if (character.IsOnPlayerTeam)
+                        {
+                            if (HumanAIController.HasItem(character, "oxygensource", out _, conditionPercentage: min))
+                            {
+                                character.Speak(TextManager.Get("dialogswappingoxygentank"), null, 0, "swappingoxygentank", 30.0f);
+                            }
+                            else
+                            {
+                                character.Speak(TextManager.Get("DialogGetOxygenTank"), null, 0, "getoxygentank", 30.0f);
+                            }
+                        }
+                        return new AIObjectiveContainItem(character, OXYGEN_SOURCE, targetItem.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC)
                         {
                             AllowToFindDivingGear = false,
                             AllowDangerousPressure = true,
@@ -80,20 +93,45 @@ namespace Barotrauma
                     },
                     onAbandon: () =>
                     {
+                        int remainingTanks = ReportOxygenTankCount();
                         // Try to seek any oxygen sources.
                         TryAddSubObjective(ref getOxygen, () =>
                         {
-                            return new AIObjectiveContainItem(character, OXYGEN_SOURCE, targetItem.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC)
+                            return new AIObjectiveContainItem(character, OXYGEN_SOURCE, targetItem.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC)
                             {
                                 AllowToFindDivingGear = false,
-                                AllowDangerousPressure = true,
-                                ConditionLevel = 0
+                                AllowDangerousPressure = true
                             };
                         },
-                        onAbandon: () => Abandon = true,
+                        onAbandon: () =>
+                        {
+                            Abandon = true;
+                            if (remainingTanks > 0 && !HumanAIController.HasItem(character, "oxygensource", out _, conditionPercentage: 0.01f))
+                            {
+                                character.Speak(TextManager.Get("dialogcantfindtoxygen"), null, 0, "cantfindoxygen", 30.0f);
+                            }
+                        },
                         onCompleted: () => RemoveSubObjective(ref getOxygen));
                     },
-                    onCompleted: () => RemoveSubObjective(ref getOxygen));
+                    onCompleted: () =>
+                    {
+                        RemoveSubObjective(ref getOxygen);
+                        ReportOxygenTankCount();
+                    });
+
+                    int ReportOxygenTankCount()
+                    {
+                        int remainingOxygenTanks = Submarine.MainSub.GetItems(false).Count(i => i.HasTag("oxygensource") && i.Condition > 1);
+                        if (remainingOxygenTanks == 0)
+                        {
+                            character.Speak(TextManager.Get("DialogOutOfOxygenTanks"), null, 0.0f, "outofoxygentanks", 30.0f);
+                        }
+                        else if (remainingOxygenTanks < 10)
+                        {
+                            character.Speak(TextManager.Get("DialogLowOnOxygenTanks"), null, 0.0f, "lowonoxygentanks", 30.0f);
+                        }
+                        return remainingOxygenTanks;
+                    }
                 }
             }
         }
@@ -101,21 +139,11 @@ namespace Barotrauma
         /// <summary>
         /// Returns false only when no inventory can be found from the item.
         /// </summary>
-        public static bool DropEmptyTanks(Character actor, Item target, out Item[] containedItems)
+        public static bool EjectEmptyTanks(Character actor, Item target, out IEnumerable<Item> containedItems)
         {
-            containedItems = target.OwnInventory?.Items;
-            if (containedItems == null)
-            {
-                return false;
-            }
-            foreach (Item containedItem in containedItems)
-            {
-                if (containedItem == null) { continue; }
-                if (containedItem.Condition <= 0.0f)
-                {
-                    containedItem.Drop(actor);
-                }
-            }
+            containedItems = target.OwnInventory?.AllItems;
+            if (containedItems == null) { return false; }
+            AIController.UnequipEmptyItems(actor, target);
             return true;
         }
 

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

@@ -46,19 +46,24 @@ namespace Barotrauma
             }
             if (character.CurrentHull == null)
             {
-                Priority = objectiveManager.CurrentOrder is AIObjectiveGoTo && HumanAIController.HasDivingSuit(character) ? 0 : 100;
+                Priority = (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() || objectiveManager.HasActiveObjective<AIObjectiveCombat>()) && HumanAIController.HasDivingSuit(character) ? 0 : 100;
             }
             else
             {
-                if (HumanAIController.NeedsDivingGear(character.CurrentHull, out _) && !HumanAIController.HasDivingGear(character))
+                if (HumanAIController.NeedsDivingGear(character.CurrentHull, out _) && !HumanAIController.HasDivingGear(character, conditionPercentage: AIObjectiveFindDivingGear.MIN_OXYGEN))
                 {
                     Priority = 100;
                 }
+                else if (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() && character.Submarine != null && !HumanAIController.IsOnFriendlyTeam(character.TeamID, character.Submarine.TeamID))
+                {
+                    // Ordered to follow/hold position inside a hostile sub -> ignore find safety unless we need to find a diving gear
+                    Priority = 0;
+                }
                 Priority = MathHelper.Clamp(Priority, 0, 100);
                 if (divingGearObjective != null && !divingGearObjective.IsCompleted && divingGearObjective.CanBeCompleted)
                 {
                     // Boost the priority while seeking the diving gear
-                    Priority = Math.Max(Priority, Math.Min(AIObjectiveManager.OrderPriority + 20, 100));
+                    Priority = Math.Max(Priority, Math.Min(AIObjectiveManager.HighestOrderPriority + 20, 100));
                 }
             }
             return Priority;
@@ -168,7 +173,7 @@ namespace Barotrauma
                 {
                     searchHullTimer = SearchHullInterval * Rand.Range(0.9f, 1.1f);
                     previousSafeHull = currentSafeHull;
-                    currentSafeHull = FindBestHull(allowChangingTheSubmarine: character.TeamID != Character.TeamType.FriendlyNPC);
+                    currentSafeHull = FindBestHull(allowChangingTheSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
                     cannotFindSafeHull = currentSafeHull == null || HumanAIController.NeedsDivingGear(currentSafeHull, out _);
                     if (currentSafeHull == null)
                     {
@@ -359,7 +364,7 @@ namespace Barotrauma
                     hullSafety *= distanceFactor;
                     // If the target is not inside a friendly submarine, considerably reduce the hull safety.
                     // Intentionally exclude wrecks from this check
-                    if (hull.Submarine.TeamID != character.TeamID && hull.Submarine.TeamID != Character.TeamType.FriendlyNPC)
+                    if (hull.Submarine.TeamID != character.TeamID && hull.Submarine.TeamID != CharacterTeamType.FriendlyNPC)
                     {
                         hullSafety /= 10;
                     }

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

@@ -52,7 +52,7 @@ namespace Barotrauma
                 float distanceFactor = isPriority || xDist < 200 && yDist < 100 ? 1 : MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 3000, xDist + yDist * 3.0f));
                 float severity = isPriority ? 1 : AIObjectiveFixLeaks.GetLeakSeverity(Leak) / 100;
                 float reduction = isPriority ? 1 : 2;
-                float max = MathHelper.Min(AIObjectiveManager.OrderPriority - reduction, 90);
+                float max = AIObjectiveManager.LowestOrderPriority - reduction;
                 float devotion = CumulatedDevotion / 100;
                 Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (severity * distanceFactor * PriorityModifier), 0, 1));
             }
@@ -64,10 +64,10 @@ namespace Barotrauma
             var weldingTool = character.Inventory.FindItemByTag("weldingequipment", true);
             if (weldingTool == null)
             {
-                TryAddSubObjective(ref getWeldingTool, () => new AIObjectiveGetItem(character, "weldingequipment", objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC), 
+                TryAddSubObjective(ref getWeldingTool, () => new AIObjectiveGetItem(character, "weldingequipment", objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC), 
                     onAbandon: () =>
                     {
-                        if (objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>())
+                        if (character.IsOnPlayerTeam && objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>())
                         {
                             character.Speak(TextManager.Get("dialogcannotfindweldingequipment"), null, 0.0f, "dialogcannotfindweldingequipment", 10.0f);
                         }
@@ -78,8 +78,7 @@ namespace Barotrauma
             }
             else
             {
-                var containedItems = weldingTool.OwnInventory?.Items;
-                if (containedItems == null)
+                if (weldingTool.OwnInventory == null)
                 {
 #if DEBUG
                     DebugConsole.ThrowError($"{character.Name}: AIObjectiveFixLeak failed - the item \"" + weldingTool + "\" has no proper inventory");
@@ -88,19 +87,34 @@ namespace Barotrauma
                     return;
                 }
                 // Drop empty tanks
-                foreach (Item containedItem in containedItems)
+                HumanAIController.UnequipEmptyItems(weldingTool);
+
+                if (weldingTool.OwnInventory.AllItems.None(i => i.HasTag("weldingfuel") && i.Condition > 0.0f))
                 {
-                    if (containedItem == null) { continue; }
-                    if (containedItem.Condition <= 0.0f)
+                    TryAddSubObjective(ref refuelObjective, () => new AIObjectiveContainItem(character, "weldingfuel", weldingTool.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC),
+                        onAbandon: () =>
+                        {
+                            Abandon = true;
+                            ReportWeldingFuelTankCount();
+                        },
+                        onCompleted: () => 
+                        {
+                            RemoveSubObjective(ref refuelObjective);
+                            ReportWeldingFuelTankCount();
+                        });
+
+                    void ReportWeldingFuelTankCount()
                     {
-                        containedItem.Drop(character);
+                        int remainingOxygenTanks = Submarine.MainSub.GetItems(false).Count(i => i.HasTag("weldingfuel") && i.Condition > 1);
+                        if (remainingOxygenTanks == 0)
+                        {
+                            character.Speak(TextManager.Get("DialogOutOfWeldingFuel"), null, 0.0f, "outofweldingfuel", 30.0f);
+                        }
+                        else if (remainingOxygenTanks < 4)
+                        {
+                            character.Speak(TextManager.Get("DialogLowOnWeldingFuel"), null, 0.0f, "lowonweldingfuel", 30.0f);
+                        }
                     }
-                }
-                if (containedItems.None(i => i != null && i.HasTag("weldingfuel") && i.Condition > 0.0f))
-                {
-                    TryAddSubObjective(ref refuelObjective, () => new AIObjectiveContainItem(character, "weldingfuel", weldingTool.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC), 
-                        onAbandon: () => Abandon = true,
-                        onCompleted: () => RemoveSubObjective(ref refuelObjective));
                     return;
                 }
             }

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

@@ -42,7 +42,7 @@ namespace Barotrauma
             if (totalLeaks == 0) { return 0; }
             int otherFixers = HumanAIController.CountCrew(c => c != HumanAIController && c.ObjectiveManager.IsCurrentObjective<AIObjectiveFixLeaks>() && !c.Character.IsIncapacitated, onlyBots: true);
             bool anyFixers = otherFixers > 0;
-            if (objectiveManager.CurrentOrder == this)
+            if (objectiveManager.IsOrder(this))
             {
                 float ratio = anyFixers ? totalLeaks / (float)otherFixers : 1;
                 return Targets.Sum(t => GetLeakSeverity(t)) * ratio;
@@ -72,7 +72,11 @@ namespace Barotrauma
         {
             if (gap == null) { return false; }
             // Don't fix a leak on a wall section set to be ignored
-            if (gap.ConnectedWall?.Sections?.Any(s => s.gap == gap && s.IgnoreByAI) ?? false) { return false; } 
+            if (gap.ConnectedWall != null)
+            {
+                if (gap.ConnectedWall.Sections.Any(s => s.gap == gap && s.IgnoreByAI)) { return false; } 
+                if (gap.ConnectedWall.MaxHealth <= 0.0f) { return false; }
+            }
             if (gap.ConnectedWall == null || gap.ConnectedDoor != null || gap.Open <= 0 || gap.linkedTo.All(l => l == null)) { return false; }
             if (gap.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.

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

@@ -44,6 +44,8 @@ namespace Barotrauma
         /// </summary>
         public bool AllowStealing { get; set; }
 
+        public bool TakeWholeStack { get; set; }
+
         public AIObjectiveGetItem(Character character, Item targetItem, AIObjectiveManager objectiveManager, bool equip = true, float priorityModifier = 1) 
             : base(character, objectiveManager, priorityModifier)
         {
@@ -177,7 +179,7 @@ namespace Barotrauma
             }
             else if (moveToTarget is Item parentItem)
             {
-                canInteract = character.CanInteractWith(parentItem, out _, checkLinked: false);
+                canInteract = character.CanInteractWith(parentItem, checkLinked: false);
             }
             if (canInteract)
             {
@@ -191,8 +193,20 @@ namespace Barotrauma
                     return;
                 }
 
+                Inventory itemInventory = targetItem.ParentInventory;
+                var slots = itemInventory?.FindIndices(targetItem);
                 if (HumanAIController.TakeItem(targetItem, character.Inventory, equip, storeUnequipped: true))
                 {
+                    if (TakeWholeStack && slots != null)
+                    {
+                        foreach (int slot in slots)
+                        {
+                            foreach (Item item in itemInventory.GetItemsAt(slot).ToList())
+                            {
+                                HumanAIController.TakeItem(item, character.Inventory, equip: false, storeUnequipped: true);
+                            }
+                        }
+                    }
                     IsCompleted = true;
                 }
                 else
@@ -211,7 +225,16 @@ namespace Barotrauma
                         return new AIObjectiveGoTo(moveToTarget, character, objectiveManager, repeat: false, getDivingGearIfNeeded: AllowToFindDivingGear, closeEnough: DefaultReach)
                         {
                             // If the root container changes, the item is no longer where it was (taken by someone -> need to find another item)
-                            abortCondition = () => targetItem == null || targetItem.GetRootInventoryOwner() != moveToTarget,
+                            abortCondition = obj =>
+                            {
+                                bool abort = targetItem == null || targetItem.GetRootInventoryOwner() != moveToTarget;
+                                if (abort)
+                                {
+                                    // Fail silently if someone takes the suit.
+                                    obj.speakIfFails = false;
+                                }
+                                return abort;
+                            },
                             DialogueIdentifier = "dialogcannotreachtarget",
                             TargetName = (moveToTarget as MapEntity)?.Name ?? (moveToTarget as Character)?.Name ?? moveToTarget.ToString()
                         };
@@ -256,7 +279,7 @@ namespace Barotrauma
                 if (mySub == null) { continue; }
                 if (!AllowStealing)
                 {
-                    if (character.TeamID == Character.TeamType.FriendlyNPC != item.SpawnedInOutpost) { continue; }
+                    if (character.TeamID == CharacterTeamType.FriendlyNPC != item.SpawnedInOutpost) { continue; }
                 }
                 if (!CheckItem(item)) { continue; }
                 if (ignoredContainerIdentifiers != null && item.Container != null)
@@ -276,6 +299,10 @@ namespace Barotrauma
                     itemPriority = GetItemPriority(item);
                 }
                 Entity rootInventoryOwner = item.GetRootInventoryOwner();
+                if (rootInventoryOwner is Item ownerItem)
+                {
+                    if (!ownerItem.IsInteractable(character)) { continue; }
+                }
                 Vector2 itemPos = (rootInventoryOwner ?? item).WorldPosition;
                 float yDist = Math.Abs(character.WorldPosition.Y - itemPos.Y);
                 yDist = yDist > 100 ? yDist * 5 : 0;
@@ -308,7 +335,7 @@ namespace Barotrauma
                             Entity.Spawner.AddToSpawnQueue(prefab, character.Inventory, onSpawned: (Item spawnedItem) => 
                             {
                                 targetItem = spawnedItem; 
-                                if (character.TeamID == Character.TeamType.FriendlyNPC && (character.Submarine?.Info.IsOutpost ?? false))
+                                if (character.TeamID == CharacterTeamType.FriendlyNPC && (character.Submarine?.Info.IsOutpost ?? false))
                                 {
                                     spawnedItem.SpawnedInOutpost = true;
                                 }
@@ -347,7 +374,7 @@ namespace Barotrauma
 
         private bool CheckItem(Item item)
         {
-            if (item.NonInteractable) { return false; }
+            if (!item.IsInteractable(character)) { return false; }
             if (item.IsThisOrAnyContainerIgnoredByAI()) { return false; }
             if (ignoredItems.Contains(item)) { return false; };
             if (item.Condition < TargetCondition) { return false; }

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

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Barotrauma.Extensions;
 
 namespace Barotrauma
 {
@@ -22,18 +23,22 @@ namespace Barotrauma
         /// <summary>
         /// Aborts the objective when this condition is true
         /// </summary>
-        public Func<bool> abortCondition;
+        public Func<AIObjectiveGoTo, bool> abortCondition;
         public Func<PathNode, bool> endNodeFilter;
 
         public Func<float> priorityGetter;
 
         public bool followControlledCharacter;
         public bool mimic;
+        public bool speakIfFails = true;
 
         public float extraDistanceWhileSwimming;
         public float extraDistanceOutsideSub;
         private float _closeEnough = 50;
         private readonly float minDistance = 50;
+        private readonly float seekGapsInterval = 1;
+        private float seekGapsTimer;
+
         /// <summary>
         /// Display units
         /// </summary>
@@ -76,7 +81,7 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
-            bool isOrder = objectiveManager.CurrentOrder == this;
+            bool isOrder = objectiveManager.IsOrder(this);
             if (!IsAllowed)
             {
                 Priority = 0;
@@ -110,12 +115,14 @@ namespace Barotrauma
                 }
                 else
                 {
-                    Priority = isOrder ? AIObjectiveManager.OrderPriority : 10;
+                    Priority = isOrder ? objectiveManager.GetOrderPriority(this) : 10;
                 }
             }
             return Priority;
         }
 
+        private readonly float avoidLookAheadDistance = 5;
+
         public AIObjectiveGoTo(ISpatialEntity target, Character character, AIObjectiveManager objectiveManager, bool repeat = false, bool getDivingGearIfNeeded = true, float priorityModifier = 1, float closeEnough = 0)
             : base(character, objectiveManager, priorityModifier)
         {
@@ -140,10 +147,11 @@ namespace Barotrauma
 
         private void SpeakCannotReach()
         {
+            if (!character.IsOnPlayerTeam) { return; }
 #if DEBUG
             DebugConsole.NewMessage($"{character.Name}: Cannot reach the target: {Target}", Color.Yellow);
 #endif
-            if (objectiveManager.CurrentOrder != null && DialogueIdentifier != null)
+            if (objectiveManager.HasOrders() && DialogueIdentifier != null && speakIfFails)
             {
                 string msg = TargetName == null ? TextManager.Get(DialogueIdentifier, true) : TextManager.GetWithVariable(DialogueIdentifier, "[name]", TargetName, formatCapitals: !(Target is Character));
                 if (msg != null)
@@ -157,10 +165,9 @@ namespace Barotrauma
         {
             if (followControlledCharacter)
             {
-                if (Character.Controlled == null)
+                if (Character.Controlled == null || !HumanAIController.IsFriendly(Character.Controlled))
                 {
                     Abandon = true;
-                    SteeringManager.Reset();
                     return;
                 }
                 Target = Character.Controlled;
@@ -181,7 +188,6 @@ namespace Barotrauma
                 if (e.Removed)
                 {
                     Abandon = true;
-                    SteeringManager.Reset();
                     return;
                 }
                 else
@@ -193,7 +199,7 @@ namespace Barotrauma
             if (!followControlledCharacter)
             {
                 // 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 = HumanAIController.CurrentOrder == null && !HumanAIController.ObjectiveManager.CurrentObjective.IgnoreUnsafeHulls
+                bool containsUnsafeNodes = character.IsDismissed && !HumanAIController.ObjectiveManager.CurrentObjective.IgnoreUnsafeHulls
                     && PathSteering != null && PathSteering.CurrentPath != null
                     && PathSteering.CurrentPath.Nodes.Any(n => HumanAIController.UnsafeHulls.Contains(n.CurrentHull));
                 if (containsUnsafeNodes || HumanAIController.UnreachableHulls.Contains(targetHull))
@@ -208,14 +214,14 @@ namespace Barotrauma
             {
                 Abandon = true;
             }
-            else if (waitUntilPathUnreachable < 0)
+            else if (SteeringManager == PathSteering && PathSteering.CurrentPath != null && PathSteering.CurrentPath.Unreachable && !PathSteering.IsPathDirty)
             {
-                if (SteeringManager == PathSteering && PathSteering.CurrentPath != null && PathSteering.CurrentPath.Unreachable && !PathSteering.IsPathDirty)
+                SteeringManager.Reset();
+                if (waitUntilPathUnreachable < 0)
                 {
                     if (repeat)
                     {
                         SpeakCannotReach();
-                        SteeringManager.Reset();
                     }
                     else
                     {
@@ -223,12 +229,7 @@ namespace Barotrauma
                     }
                 }
             }
-            if (Abandon)
-            {
-                SpeakCannotReach();
-                SteeringManager.Reset();
-            }
-            else
+            if (!Abandon)
             {
                 if (getDivingGearIfNeeded && !character.LockHands)
                 {
@@ -248,13 +249,14 @@ namespace Barotrauma
                         }
                     }
                     bool needsEquipment = false;
+                    float minOxygen = character.Submarine == null ? 0 : AIObjectiveFindDivingGear.MIN_OXYGEN;
                     if (needsDivingSuit)
                     {
-                        needsEquipment = !HumanAIController.HasDivingSuit(character, AIObjectiveFindDivingGear.MIN_OXYGEN);
+                        needsEquipment = !HumanAIController.HasDivingSuit(character, minOxygen);
                     }
                     else if (needsDivingGear)
                     {
-                        needsEquipment = !HumanAIController.HasDivingGear(character, AIObjectiveFindDivingGear.MIN_OXYGEN);
+                        needsEquipment = !HumanAIController.HasDivingGear(character, minOxygen);
                     }
                     if (needsEquipment)
                     {
@@ -286,52 +288,134 @@ namespace Barotrauma
                         }
                     }
                 }
-                if (!character.AnimController.InWater)
+                if (character.AnimController.InWater)
                 {
-                    useScooter = false;
-                    checkScooterTimer = 0;
-                }
-                else if (checkScooterTimer <= 0)
-                {
-                    useScooter = false;
-                    checkScooterTimer = checkScooterTime;
-                    string scooterTag = "scooter";
-                    string batteryTag = "mobilebattery";
-                    Item scooter = null;
-                    bool isScooterEquipped = false;
-                    float closeEnough = 250;
-                    float squaredDistance = Vector2.DistanceSquared(character.WorldPosition, Target.WorldPosition);
-                    bool shouldUseScooter = squaredDistance > closeEnough * closeEnough && (!mimic ||
-                        (Target is Character targetCharacter && targetCharacter.HasEquippedItem(scooterTag, allowBroken: false)) || squaredDistance > Math.Pow(closeEnough * 2, 2));
-                    if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> equippedScooters, batteryTag, requireEquipped: true))
+                    if (character.CurrentHull == null)
                     {
-                        scooter = equippedScooters.FirstOrDefault();
-                        isScooterEquipped = scooter != null;
-                    }
-                    else if (shouldUseScooter && HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> scooters, batteryTag, requireEquipped: false))
-                    {
-                        scooter = scooters.FirstOrDefault();
-                        if (scooter != null)
+                        if (seekGapsTimer > 0)
                         {
-                            isScooterEquipped = HumanAIController.TakeItem(scooter, character.Inventory, equip: true, dropOtherIfCannotMove: false, allowSwapping: true, storeUnequipped: false);
-                        }
-                    }
-                    if (scooter != null && isScooterEquipped)
-                    {
-                        if (shouldUseScooter)
-                        {
-                            useScooter = true;
+                            seekGapsTimer -= deltaTime;
                         }
                         else
                         {
-                            // Unequip
-                            character.Inventory.TryPutItem(scooter, character, CharacterInventory.anySlot);
+                            SeekGaps(maxDistance: 500);
+                            seekGapsTimer = seekGapsInterval * Rand.Range(0.1f, 1.1f);
+                            if (TargetGap != null)
+                            {
+                                // Check that nothing is blocking the way
+                                Vector2 rayStart = character.SimPosition;
+                                Vector2 rayEnd = TargetGap.SimPosition;
+                                if (TargetGap.Submarine != null && character.Submarine == null)
+                                {
+                                    rayStart -= TargetGap.Submarine.SimPosition;
+                                }
+                                else if (TargetGap.Submarine == null && character.Submarine != null)
+                                {
+                                    rayEnd -= character.Submarine.SimPosition;
+                                }
+                                var closestBody = Submarine.CheckVisibility(rayStart, rayEnd, ignoreSubs: true);
+                                if (closestBody != null)
+                                {
+                                    TargetGap = null;
+                                }
+                            }
                         }
                     }
+                    else
+                    {
+                        TargetGap = null;
+                    }
+                    if (TargetGap != null)
+                    {
+                        if (TargetGap.FlowTargetHull != null && HumanAIController.SteerThroughGap(TargetGap, TargetGap.FlowTargetHull.WorldPosition, deltaTime))
+                        {
+                            SteeringManager.SteeringAvoid(deltaTime, avoidLookAheadDistance, weight: 1);
+                            return;
+                        }
+                        else
+                        {
+                            TargetGap = null;
+                        }
+                    }
+                    if (checkScooterTimer <= 0)
+                    {
+                        useScooter = false;
+                        checkScooterTimer = checkScooterTime;
+                        string scooterTag = "scooter";
+                        string batteryTag = "mobilebattery";
+                        Item scooter = null;
+                        float closeEnough = 250;
+                        float squaredDistance = Vector2.DistanceSquared(character.WorldPosition, Target.WorldPosition);
+                        bool shouldUseScooter = squaredDistance > closeEnough * closeEnough && (!mimic ||
+                            (Target is Character targetCharacter && targetCharacter.HasEquippedItem(scooterTag, allowBroken: false)) || squaredDistance > Math.Pow(closeEnough * 2, 2));
+                        if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> equippedScooters, recursive: false, requireEquipped: true))
+                        {
+                            // Currently equipped scooter
+                            scooter = equippedScooters.FirstOrDefault();
+                        }
+                        else if (shouldUseScooter)
+                        {
+                            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);
+                        if (scooter != null && isScooterEquipped)
+                        {
+                            if (shouldUseScooter)
+                            {
+                                useScooter = true;
+                                // Check the battery
+                                if (scooter.ContainedItems.None(i => i.Condition > 0))
+                                {
+                                    // Try to switch batteries
+                                    if (HumanAIController.HasItem(character, batteryTag, out IEnumerable<Item> batteries, conditionPercentage: 1, recursive: false))
+                                    {
+                                        scooter.ContainedItems.ForEachMod(emptyBattery => character.Inventory.TryPutItem(emptyBattery, character, CharacterInventory.anySlot));
+                                        if (!scooter.Combine(batteries.OrderByDescending(b => b.Condition).First(), character))
+                                        {
+                                            useScooter = false;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        useScooter = false;
+                                    }
+                                }
+                            }
+                            if (!useScooter)
+                            {
+                                // Unequip
+                                character.Inventory.TryPutItem(scooter, character, CharacterInventory.anySlot);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        checkScooterTimer -= deltaTime;
+                    }
                 }
                 else
                 {
-                    checkScooterTimer -= deltaTime;
+                    TargetGap = null;
+                    useScooter = false;
+                    checkScooterTimer = 0;
                 }
                 if (SteeringManager == PathSteering)
                 {
@@ -347,7 +431,7 @@ namespace Barotrauma
                         nodeFilter, 
                         CheckVisibility);
 
-                    if (!isInside && PathSteering.CurrentPath == null || PathSteering.IsPathDirty || PathSteering.CurrentPath.Unreachable)
+                    if (!isInside && (PathSteering.CurrentPath == null || PathSteering.IsPathDirty || PathSteering.CurrentPath.Unreachable))
                     {
                         if (useScooter)
                         {
@@ -358,7 +442,7 @@ namespace Barotrauma
                             SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(Target.WorldPosition - character.WorldPosition));
                             if (character.AnimController.InWater)
                             {
-                                SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: 5, weight: 2);
+                                SteeringManager.SteeringAvoid(deltaTime, avoidLookAheadDistance, weight: 2);
                             }
                         }
                     }
@@ -378,7 +462,7 @@ namespace Barotrauma
                         SteeringManager.SteeringSeek(character.GetRelativeSimPosition(Target), 10);
                         if (character.AnimController.InWater)
                         {
-                            SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: 5, weight: 15);
+                            SteeringManager.SteeringAvoid(deltaTime, avoidLookAheadDistance, weight: 15);
                         }
                     }
                 }
@@ -439,6 +523,27 @@ namespace Barotrauma
             return null;
         }
 
+        public Gap TargetGap { get; private set; }
+        private void SeekGaps(float maxDistance)
+        {
+            Gap selectedGap = null;
+            float selectedDistance = -1;
+            foreach (Gap gap in Gap.GapList)
+            {
+                if (gap.Open < 1) { continue; }
+                if (gap.FlowTargetHull == null) { continue; } 
+                if (gap.Submarine != Target.Submarine) { continue; }
+                float distance = Vector2.DistanceSquared(character.WorldPosition, gap.WorldPosition);
+                if (distance > maxDistance * maxDistance) { continue; }
+                if (selectedGap == null || distance < selectedDistance)
+                {
+                    selectedGap = gap;
+                    selectedDistance = distance;
+                }
+            }
+            TargetGap = selectedGap;
+        }
+
         public bool IsCloseEnough
         {
             get
@@ -465,7 +570,7 @@ namespace Barotrauma
                 Abandon = true;
                 return false;
             }
-            if (abortCondition != null && abortCondition())
+            if (abortCondition != null && abortCondition(this))
             {
                 Abandon = true;
                 return false;
@@ -507,12 +612,13 @@ namespace Barotrauma
             {
                 PathSteering.ResetPath();
             }
+            SpeakCannotReach();
             base.OnAbandon();
         }
 
         private void StopMovement()
         {
-            character.AIController.SteeringManager.Reset();
+            SteeringManager.Reset();
             if (Target != null)
             {
                 character.AnimController.TargetDir = Target.WorldPosition.X > character.WorldPosition.X ? Direction.Right : Direction.Left;
@@ -530,6 +636,8 @@ namespace Barotrauma
         {
             base.Reset();
             findDivingGear = null;
+            seekGapsTimer = 0;
+            TargetGap = null;
         }
     }
 }

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

@@ -21,9 +21,9 @@ namespace Barotrauma
             set
             {
                 behavior = value;
-                if (behavior == BehaviorType.StayInHull && character.TeamID != Character.TeamType.FriendlyNPC)
+                if (behavior == BehaviorType.StayInHull && TargetHull == null)
                 {
-                    DebugConsole.NewMessage($"AIObjectiveIdle.BehaviorType.StayInHull is implemented only for outpost NPCs. Using passive behavior for {character.Name} ({character.Info.Job.Prefab.Identifier})", color: Color.Red);
+                    DebugConsole.AddWarning($"Trying to set a character's behavior type to StayInHull, but target hull is not set. {character.Name} ({character.Info.Job.Prefab.Identifier})");
                     behavior = BehaviorType.Passive;
                 }
                 switch (behavior)
@@ -203,7 +203,7 @@ namespace Barotrauma
 
                 if (currentTarget != null && !currentTargetIsInvalid)
                 {
-                    if (character.TeamID == Character.TeamType.FriendlyNPC)
+                    if (character.TeamID == CharacterTeamType.FriendlyNPC)
                     {
                         if (currentTarget.Submarine.TeamID != character.TeamID)
                         {
@@ -260,7 +260,7 @@ namespace Barotrauma
                     {
                         //choose a random available hull
                         currentTarget = ToolBox.SelectWeightedRandom(targetHulls, hullWeights, Rand.RandSync.Unsynced);
-                        bool isInWrongSub = character.TeamID == Character.TeamType.FriendlyNPC && character.Submarine.TeamID != character.TeamID;
+                        bool isInWrongSub = character.TeamID == CharacterTeamType.FriendlyNPC && character.Submarine.TeamID != character.TeamID;
                         bool isCurrentHullAllowed = !isInWrongSub && !IsForbidden(character.CurrentHull);
                         var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: $"AIObjectiveIdle {character.DisplayName}", nodeFilter: node =>
                         {
@@ -319,14 +319,14 @@ namespace Barotrauma
         public void Wander(float deltaTime)
         {
             if (character.IsClimbing) { return; }
-            if (!character.AnimController.InWater)
+            var currentHull = character.CurrentHull;
+            if (!character.AnimController.InWater && currentHull != null)
             {
                 standStillTimer -= deltaTime;
                 if (standStillTimer > 0.0f)
                 {
                     walkDuration = Rand.Range(walkDurationMin, walkDurationMax);
-                    var currentHull = character.CurrentHull;
-                    if (currentHull != null && currentHull.Rect.Width > IndoorsSteeringManager.smallRoomSize / 2 && tooCloseCharacter == null)
+                    if (currentHull.Rect.Width > IndoorsSteeringManager.smallRoomSize / 2 && tooCloseCharacter == null)
                     {
                         foreach (Character c in Character.CharacterList)
                         {
@@ -402,6 +402,14 @@ namespace Barotrauma
             PathSteering.Wander(deltaTime);
         }
 
+        public void FaceTargetAndWait(ISpatialEntity target, float waitTime)
+        {
+            standStillTimer = waitTime;
+            HumanAIController.FaceTarget(target);
+            currentTarget = null;
+            SetTargetTimerHigh();
+        }
+
         private void FindTargetHulls()
         {
             targetHulls.Clear();
@@ -411,7 +419,7 @@ namespace Barotrauma
                 if (HumanAIController.UnsafeHulls.Contains(hull)) { continue; }
                 if (hull.Submarine == null) { continue; }
                 if (character.Submarine == null) { break; }
-                if (character.TeamID == Character.TeamType.FriendlyNPC)
+                if (character.TeamID == CharacterTeamType.FriendlyNPC)
                 {
                     if (hull.Submarine.TeamID != character.TeamID)
                     {
@@ -487,7 +495,7 @@ namespace Barotrauma
                     foreach (Item item in Item.ItemList)
                     {
                         if (item.CurrentHull != hull) { continue; }
-                        if (AIObjectiveCleanupItems.IsValidTarget(item, character) && !ignoredItems.Contains(item))
+                        if (AIObjectiveCleanupItems.IsValidTarget(item, character, checkInventory: true) && !ignoredItems.Contains(item))
                         {
                             itemsToClean.Add(item);
                         }

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

@@ -139,13 +139,13 @@ namespace Barotrauma
                 }
                 else
                 {
-                    if (objectiveManager.CurrentOrder == this)
+                    if (objectiveManager.IsOrder(this))
                     {
-                        Priority = ForceOrderPriority ? AIObjectiveManager.OrderPriority : targetValue;
+                        Priority = ForceOrderPriority ? objectiveManager.GetOrderPriority(this) : targetValue;
                     }
                     else
                     {
-                        float max = MathHelper.Min(AIObjectiveManager.OrderPriority - 1, 90);
+                        float max = AIObjectiveManager.LowestOrderPriority - 1;
                         float value = MathHelper.Clamp((CumulatedDevotion + (targetValue * PriorityModifier)) / 100, 0, 1);
                         Priority = MathHelper.Lerp(0, max, value);
                     }
@@ -167,7 +167,7 @@ namespace Barotrauma
             foreach (T target in GetList())
             {
                 // The bots always find targets when the objective is an order.
-                if (objectiveManager.CurrentOrder != this)
+                if (!objectiveManager.IsOrder(this))
                 {
                     // Battery or pump states cannot currently be reported (not implemented) and therefore we must ignore them -> the bots always know if they require attention.
                     bool ignore = this is AIObjectiveChargeBatteries || this is AIObjectivePumpWater;

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

@@ -1,6 +1,6 @@
 using Barotrauma.Extensions;
 using Barotrauma.Items.Components;
-using Barotrauma.Networking;
+using Barotrauma.Networking; // used by the server
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
@@ -10,8 +10,8 @@ namespace Barotrauma
 {
     class AIObjectiveManager
     {
-        // TODO: expose
-        public const float OrderPriority = 70;
+        public const float HighestOrderPriority = 70;
+        public const float LowestOrderPriority = 60;
         public const float RunPriority = 50;
         // Constantly increases the priority of the selected objective, unless overridden
         public const float baseDevotion = 5;
@@ -25,7 +25,6 @@ namespace Barotrauma
 
         public HumanAIController HumanAIController => character.AIController as HumanAIController;
 
-
         private float _waitTimer;
         /// <summary>
         /// When set above zero, the character will stand still doing nothing until the timer runs out. Does not affect orders, find safety or combat.
@@ -39,26 +38,25 @@ namespace Barotrauma
             }
         }
 
-        public AIObjective CurrentOrder { get; private set; }
+        public List<OrderInfo> CurrentOrders { get; } = new List<OrderInfo>();
+        /// <summary>
+        /// The AIObjective in <see cref="CurrentOrders"/> with the highest <see cref="AIObjective.Priority"/>
+        /// </summary>
+        public AIObjective CurrentOrder
+        {
+            get
+            {
+                return ForcedOrder ?? currentOrder;
+            }
+            private set
+            {
+                currentOrder = value;
+            }
+        }
+        private AIObjective currentOrder;
+        public AIObjective ForcedOrder { get; private set; }
         public AIObjective CurrentObjective { get; private set; }
 
-        public bool IsCurrentOrder<T>() where T : AIObjective => CurrentOrder is T;
-        public bool IsCurrentObjective<T>() where T : AIObjective => CurrentObjective is T;
-        public bool IsActiveObjective<T>() where T : AIObjective => GetActiveObjective() is T;
-
-        public AIObjective GetActiveObjective() => CurrentObjective?.GetActiveObjective();
-        /// <summary>
-        /// Returns the last active objective of the specific type.
-        /// </summary>
-        public T GetActiveObjective<T>() where T : AIObjective => CurrentObjective?.GetSubObjectivesRecursive(includingSelf: true).LastOrDefault(so => so is T) as T;
-
-        /// <summary>
-        /// Returns all active objectives of the specific type. Creates a new collection -> don't use too frequently.
-        /// </summary>
-        public IEnumerable<T> GetActiveObjectives<T>() where T : AIObjective => CurrentObjective?.GetSubObjectivesRecursive(includingSelf: true).Where(so => so is T).Select(so => so as T);
-
-        public bool HasActiveObjective<T>() where T : AIObjective => CurrentObjective is T || CurrentObjective != null && CurrentObjective.GetSubObjectivesRecursive().Any(so => so is T);
-
         public AIObjectiveManager(Character character)
         {
             this.character = character;
@@ -127,10 +125,14 @@ namespace Barotrauma
             {
                 var orderPrefab = Order.GetPrefab(autonomousObjective.identifier);
                 if (orderPrefab == null) { throw new Exception($"Could not find a matching prefab by the identifier: '{autonomousObjective.identifier}'"); }
-                var item = orderPrefab.MustSetTarget ? orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID)?.GetRandom() : null;
+                Item item = null;
+                if (orderPrefab.MustSetTarget)
+                {
+                    item = orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID, interactableFor: character)?.GetRandom();
+                }
                 var order = new Order(orderPrefab, item ?? character.CurrentHull as Entity, orderPrefab.GetTargetItemComponent(item), orderGiver: character);
                 if (order == null) { continue; }
-                if (autonomousObjective.ignoreAtOutpost && Level.IsLoadedOutpost && character.TeamID != Character.TeamType.FriendlyNPC) { continue; }
+                if (autonomousObjective.ignoreAtOutpost && Level.IsLoadedOutpost && character.TeamID != CharacterTeamType.FriendlyNPC) { continue; }
                 var objective = CreateObjective(order, autonomousObjective.option, character, isAutonomous: true, autonomousObjective.priorityModifier);
                 if (objective != null && objective.CanBeCompleted)
                 {
@@ -196,21 +198,34 @@ namespace Barotrauma
 
         public void UpdateObjectives(float deltaTime)
         {
-            if (CurrentOrder != null)
+            UpdateOrderObjective(ForcedOrder);
+
+            if (CurrentOrders.Any())
             {
+                foreach(var order in CurrentOrders)
+                {
+                    var orderObjective = order.Objective;
+                    UpdateOrderObjective(orderObjective);
+                }
+            }
+
+            void UpdateOrderObjective(AIObjective orderObjective)
+            {
+                if (orderObjective == null) { return; }
 #if DEBUG
                 // Note: don't automatically remove orders here. Removing orders needs to be done via dismissing.
-                if (CurrentOrder.IsCompleted)
+                if (orderObjective.IsCompleted)
                 {
-                    DebugConsole.NewMessage($"{character.Name}: ORDER {CurrentOrder.DebugTag} IS COMPLETED. CURRENTLY ALL ORDERS SHOULD BE LOOPING.", Color.Red);
+                    DebugConsole.NewMessage($"{character.Name}: ORDER {orderObjective.DebugTag} IS COMPLETED. CURRENTLY ALL ORDERS SHOULD BE LOOPING.", Color.Red);
                 }
-                else if (!CurrentOrder.CanBeCompleted)
+                else if (!orderObjective.CanBeCompleted)
                 {
-                    DebugConsole.NewMessage($"{character.Name}: ORDER {CurrentOrder.DebugTag}, CANNOT BE COMPLETED.", Color.Red);
+                    DebugConsole.NewMessage($"{character.Name}: ORDER {orderObjective.DebugTag}, CANNOT BE COMPLETED.", Color.Red);
                 }
 #endif
-                CurrentOrder.Update(deltaTime);
+                orderObjective.Update(deltaTime);
             }
+
             if (WaitTimer > 0)
             {
                 WaitTimer -= deltaTime;
@@ -244,7 +259,29 @@ namespace Barotrauma
 
         public void SortObjectives()
         {
-            CurrentOrder?.GetPriority();
+            ForcedOrder?.GetPriority();
+
+            AIObjective orderWithHighestPriority = null;
+            float highestPriority = 0;
+            foreach (var currentOrder in CurrentOrders)
+            {
+                var orderObjective = currentOrder.Objective;
+                if (orderObjective == null) { continue; }
+                orderObjective.GetPriority();
+                if (orderWithHighestPriority == null || orderObjective.Priority > highestPriority)
+                {
+                    orderWithHighestPriority = orderObjective;
+                    highestPriority = orderObjective.Priority;
+                }
+            }
+#if SERVER
+            if (orderWithHighestPriority != null && orderWithHighestPriority != currentOrder)
+            {
+                GameMain.NetworkMember.CreateEntityEvent(character, new object[] { NetEntityEvent.Type.ObjectiveManagerOrderState });   
+            }
+#endif
+            CurrentOrder = orderWithHighestPriority;
+
             for (int i = Objectives.Count - 1; i >= 0; i--)
             {
                 Objectives[i].GetPriority();
@@ -253,6 +290,7 @@ namespace Barotrauma
             {
                 Objectives.Sort((x, y) => y.Priority.CompareTo(x.Priority));
             }
+
             GetCurrentObjective()?.SortSubObjectives();
         }
 
@@ -268,12 +306,18 @@ namespace Barotrauma
             }
         }
 
-        public void SetOrder(AIObjective objective)
+        public void SetForcedOrder(AIObjective objective)
         {
-            CurrentOrder = objective;
+            ForcedOrder = objective;
         }
 
-        public void SetOrder(Order order, string option, Character orderGiver)
+        public void ClearForcedOrder()
+        {
+            ForcedOrder = null;
+        }
+
+        private CoroutineHandle speakRoutine;
+        public void SetOrder(Order order, string option, int priority, Character orderGiver, bool speak)
         {
             if (character.IsDead)
             {
@@ -284,8 +328,53 @@ namespace Barotrauma
 #endif
             }
             ClearIgnored();
-            CurrentOrder = CreateObjective(order, option, orderGiver, isAutonomous: false);
-            if (CurrentOrder == null)
+
+            if (order == null || order.Identifier == "dismissed")
+            {
+                if (!string.IsNullOrEmpty(option))
+                {
+                    if (CurrentOrders.Any(o => o.MatchesDismissedOrder(option)))
+                    {
+                        var dismissedOrderInfo = CurrentOrders.First(o => o.MatchesDismissedOrder(option));
+                        CurrentOrders.Remove(dismissedOrderInfo);
+                    }
+                }
+                else
+                {
+                    CurrentOrders.Clear();
+                }
+            }
+
+            // Make sure the order priorities reflect those set by the player
+            for (int i = CurrentOrders.Count - 1; i >= 0; i--)
+            {
+                var currentOrder = CurrentOrders[i];
+                if (currentOrder.Objective == null || currentOrder.MatchesOrder(order, option))
+                {
+                    CurrentOrders.RemoveAt(i);
+                    continue;
+                }
+                var currentOrderInfo = character.GetCurrentOrder(currentOrder.Order, currentOrder.OrderOption);
+                if (currentOrderInfo.HasValue)
+                {
+                    int currentPriority = currentOrderInfo.Value.ManualPriority;
+                    if (currentOrder.ManualPriority != currentPriority)
+                    {
+                        CurrentOrders[i] = new OrderInfo(currentOrder, currentPriority);
+                    }
+                }
+                else
+                {
+                    CurrentOrders.RemoveAt(i);
+                }
+            }
+
+            var newCurrentOrder = CreateObjective(order, option, orderGiver, isAutonomous: false);
+            if (newCurrentOrder != null)
+            {
+                CurrentOrders.Add(new OrderInfo(order, option, priority, newCurrentOrder));
+            }
+            if (!HasOrders())
             {
                 // Recreate objectives, because some of them may be removed, if impossible to complete (e.g. due to path finding)
                 CreateAutonomousObjectives();
@@ -293,13 +382,57 @@ namespace Barotrauma
             else
             {
                 // This should be redundant, because all the objectives are reset when they are selected as active.
-                CurrentOrder.Reset();
+                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);
+                }
             }
         }
 
         public AIObjective CreateObjective(Order order, string option, Character orderGiver, bool isAutonomous, float priorityModifier = 1)
         {
-            if (order == null) { return null; }
+            if (order == null || order.Identifier == "dismissed") { return null; }
             AIObjective newObjective;
             switch (order.Identifier.ToLowerInvariant())
             {
@@ -320,8 +453,7 @@ namespace Barotrauma
                 case "wait":
                     newObjective = new AIObjectiveGoTo(order.TargetSpatialEntity ?? character, character, this, repeat: true, priorityModifier: priorityModifier)
                     {
-                        AllowGoingOutside = order.TargetSpatialEntity == null ? character.CurrentHull == null :
-                            character.Submarine == null || character.Submarine != order.TargetSpatialEntity.Submarine
+                        AllowGoingOutside = character.Submarine == null || (order.TargetSpatialEntity != null && character.Submarine != order.TargetSpatialEntity.Submarine)
                     };
                     break;
                 case "fixleaks":
@@ -345,7 +477,7 @@ namespace Barotrauma
                 case "pumpwater":
                     if (order.TargetItemComponent is Pump targetPump)
                     {
-                        if (order.TargetItemComponent.Item.NonInteractable) { return null; }
+                        if (!order.TargetItemComponent.Item.IsInteractable(character)) { return null; }
                         newObjective = new AIObjectiveOperateItem(targetPump, character, this, option, false, priorityModifier: priorityModifier)
                         {
                             IsLoop = true,
@@ -370,7 +502,7 @@ namespace Barotrauma
                     var steering = (order?.TargetEntity as Item)?.GetComponent<Steering>();
                     if (steering != null) { steering.PosToMaintain = steering.Item.Submarine?.WorldPosition; }
                     if (order.TargetItemComponent == null) { return null; }
-                    if (order.TargetItemComponent.Item.NonInteractable) { return null; }
+                    if (!order.TargetItemComponent.Item.IsInteractable(character)) { return null; }
                     newObjective = new AIObjectiveOperateItem(order.TargetItemComponent, character, this, option,
                         requireEquip: false, useController: order.UseController, controller: order.ConnectedController, priorityModifier: priorityModifier)
                     {
@@ -383,7 +515,7 @@ namespace Barotrauma
                     newObjective = new AIObjectiveOperateItem(order.TargetItemComponent, character, this, option, false, priorityModifier: priorityModifier)
                     {
                         IsLoop = false,
-                        Override = character.CurrentOrder != null,
+                        Override = !character.IsDismissed,
                         completionCondition = () =>
                         {
                             if (float.TryParse(option, out float pct))
@@ -403,11 +535,26 @@ namespace Barotrauma
                     };
                     break;
                 case "cleanupitems":
-                    newObjective = new AIObjectiveCleanupItems(character, this, priorityModifier, order.TargetEntity as Item);
+                    if (order.TargetEntity is Item targetItem)
+                    {
+                        if (targetItem.HasTag("allowcleanup") && targetItem.ParentInventory == null && targetItem.OwnInventory != null)
+                        {
+                            // Target all items inside the container
+                            newObjective = new AIObjectiveCleanupItems(character, this, targetItem.OwnInventory.AllItems, priorityModifier);
+                        }
+                        else
+                        {
+                            newObjective = new AIObjectiveCleanupItems(character, this, targetItem, priorityModifier);
+                        }
+                    }
+                    else
+                    {
+                        newObjective = new AIObjectiveCleanupItems(character, this, priorityModifier: priorityModifier);
+                    }
                     break;
                 default:
                     if (order.TargetItemComponent == null) { return null; }
-                    if (order.TargetItemComponent.Item.NonInteractable) { return null; }
+                    if (!order.TargetItemComponent.Item.IsInteractable(character)) { return null; }
                     newObjective = new AIObjectiveOperateItem(order.TargetItemComponent, character, this, option,
                         requireEquip: false, useController: order.UseController, controller: order.ConnectedController, priorityModifier: priorityModifier)
                     {
@@ -421,21 +568,9 @@ namespace Barotrauma
             return newObjective;
         }
 
-        private void DismissSelf()
-        {
-#if CLIENT
-            if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
-            {
-                GameMain.GameSession?.CrewManager?.SetCharacterOrder(character, Order.GetPrefab("dismissed"), null, character);
-            }
-#else
-            GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(Order.GetPrefab("dismissed"), null, null, character, character));
-#endif
-        }
-
         private bool IsAllowedToWait()
         {
-            if (CurrentOrder != null) { return false; }
+            if (HasOrders()) { return false; }
             if (CurrentObjective is AIObjectiveCombat || CurrentObjective is AIObjectiveFindSafety) { return false; }
             if (character.AnimController.InWater) { return false; }
             if (character.IsClimbing) { return false; }
@@ -446,5 +581,61 @@ namespace Barotrauma
             if (AIObjectiveIdle.IsForbidden(character.CurrentHull)) { return false; }
             return true;
         }
+
+        public bool IsCurrentOrder<T>() where T : AIObjective => CurrentOrder is T;
+        public bool IsCurrentObjective<T>() where T : AIObjective => CurrentObjective is T;
+        public bool IsActiveObjective<T>() where T : AIObjective => GetActiveObjective() is T;
+
+        public AIObjective GetActiveObjective() => CurrentObjective?.GetActiveObjective();
+        /// <summary>
+        /// Returns the last active objective of the specific type.
+        /// </summary>
+        public T GetActiveObjective<T>() where T : AIObjective => CurrentObjective?.GetSubObjectivesRecursive(includingSelf: true).LastOrDefault(so => so is T) as T;
+
+        /// <summary>
+        /// Returns all active objectives of the specific type. Creates a new collection -> don't use too frequently.
+        /// </summary>
+        public IEnumerable<T> GetActiveObjectives<T>() where T : AIObjective => CurrentObjective?.GetSubObjectivesRecursive(includingSelf: true).Where(so => so is T).Select(so => so as T);
+
+        public bool HasActiveObjective<T>() where T : AIObjective => CurrentObjective is T || CurrentObjective != null && CurrentObjective.GetSubObjectivesRecursive().Any(so => so is T);
+
+        public bool IsOrder(AIObjective objective)
+        {
+            return objective == ForcedOrder || CurrentOrders.Any(o => o.Objective == objective);
+        }
+
+        public bool HasOrders()
+        {
+            return ForcedOrder != null || CurrentOrders.Any();
+        }
+
+        public bool HasOrder<T>() where T : AIObjective
+        {
+            return ForcedOrder is T || CurrentOrders.Any(o => o.Objective is T);
+        }
+
+        public float GetOrderPriority(AIObjective objective)
+        {
+            if (objective == ForcedOrder) { return HighestOrderPriority; }
+            var currentOrder = CurrentOrders.FirstOrDefault(o => o.Objective == objective);
+            if (currentOrder.Objective == null)
+            {
+                return HighestOrderPriority;
+            }
+            else if (currentOrder.ManualPriority > 0)
+            {
+                return MathHelper.Lerp(LowestOrderPriority, HighestOrderPriority, MathUtils.InverseLerp(1, CharacterInfo.HighestManualOrderPriority, currentOrder.ManualPriority));
+            }
+#if DEBUG
+            DebugConsole.AddWarning("Error in order priority: shouldn't return 0!");
+#endif
+            return 0;
+        }
+
+        public OrderInfo? GetCurrentOrderInfo()
+        {
+            if (currentOrder == null) { return null; }
+            return CurrentOrders.FirstOrDefault(o => o.Objective == CurrentOrder);
+        }
     }
 }

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

@@ -36,7 +36,7 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
-            bool isOrder = objectiveManager.CurrentOrder == this;
+            bool isOrder = objectiveManager.IsOrder(this);
             if (!IsAllowed || character.LockHands)
             {
                 Priority = 0;
@@ -51,7 +51,7 @@ namespace Barotrauma
             {
                 if (isOrder)
                 {
-                    Priority = AIObjectiveManager.OrderPriority;
+                    Priority = objectiveManager.GetOrderPriority(this);
                 }
                 ItemComponent target = GetTarget();
                 Item targetItem = target?.Item;
@@ -69,7 +69,7 @@ namespace Barotrauma
                 {
                     if (!isOrder)
                     {
-                        if (reactor.LastUserWasPlayer && character.TeamID != Character.TeamType.FriendlyNPC ||
+                        if (reactor.LastUserWasPlayer && character.TeamID != CharacterTeamType.FriendlyNPC ||
                             HumanAIController.IsTrueForAnyCrewMember(c =>
                                 c.ObjectiveManager.CurrentOrder is AIObjectiveOperateItem operateOrder && operateOrder.GetTarget() == target))
                         {
@@ -89,11 +89,16 @@ namespace Barotrauma
                         case "powerup":
                             // Check that we don't already have another order that is targeting the same item.
                             // Without this the autonomous objective will tell the bot to turn the reactor on again.
-                            if (objectiveManager.CurrentOrder is AIObjectiveOperateItem operateOrder && operateOrder != this && operateOrder.GetTarget() == target && operateOrder.Option != Option)
+
+                            if (IsAnotherOrderTargetingSameItem(objectiveManager.ForcedOrder) || objectiveManager.CurrentOrders.Any(o => IsAnotherOrderTargetingSameItem(o.Objective)))
                             {
                                 Priority = 0;
                                 return Priority;
                             }
+                            bool IsAnotherOrderTargetingSameItem(AIObjective objective)
+                            {
+                                return objective is AIObjectiveOperateItem operateObjective && operateObjective != this && operateObjective.GetTarget() == target && operateObjective.Option != Option;
+                            }
                             break;
                     }
                 }
@@ -101,20 +106,30 @@ namespace Barotrauma
                     targetItem.Submarine != character.Submarine && !isOrder ||
                     targetItem.CurrentHull.FireSources.Any() ||
                     HumanAIController.IsItemOperatedByAnother(target, out _) ||
-                    Character.CharacterList.Any(c => c.CurrentHull == targetItem.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
+                    Character.CharacterList.Any(c => c.CurrentHull == targetItem.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))
+                    || component.Item.IgnoreByAI || (useController && controller.Item.IgnoreByAI))
                 {
                     Priority = 0;
                 }
                 else
                 {
-                    float value = CumulatedDevotion + (AIObjectiveManager.OrderPriority * PriorityModifier);
-                    float max = isOrder ? MathHelper.Min(AIObjectiveManager.OrderPriority, 90) : AIObjectiveManager.RunPriority - 1;
-                    if (!isOrder && reactor != null && reactor.PowerOn && Option == "powerup")
+                    if (isOrder)
                     {
-                        // Decrease the priority when targeting a reactor that is already on.
-                        value /= 2;
+                        float max = objectiveManager.GetOrderPriority(this);
+                        float value = CumulatedDevotion + (max * PriorityModifier);
+                        Priority = MathHelper.Clamp(value, 0, max);
+                    }
+                    else
+                    {
+                        float value = CumulatedDevotion + (AIObjectiveManager.LowestOrderPriority * PriorityModifier);
+                        float max = AIObjectiveManager.LowestOrderPriority - 1;
+                        if (reactor != null && reactor.PowerOn && Option == "powerup")
+                        {
+                            // Decrease the priority when targeting a reactor that is already on.
+                            value /= 2;
+                        }
+                        Priority = MathHelper.Clamp(value, 0, max);
                     }
-                    Priority = MathHelper.Clamp(value, 0, max);
                 }
             }
             return Priority;
@@ -137,7 +152,7 @@ namespace Barotrauma
                 throw new Exception("target null");
 #endif
             }
-            else if (target.Item.NonInteractable)
+            else if (!target.Item.IsInteractable(character))
             {
                 Abandon = true;
             }
@@ -153,25 +168,13 @@ namespace Barotrauma
             ItemComponent target = GetTarget();
             if (useController && controller == null)
             {
-                character.Speak(TextManager.GetWithVariable("DialogCantFindController", "[item]", component.Item.Name, true), null, 2.0f, "cantfindcontroller", 30.0f);
+                if (character.IsOnPlayerTeam)
+                {
+                    character.Speak(TextManager.GetWithVariable("DialogCantFindController", "[item]", component.Item.Name, true), null, 2.0f, "cantfindcontroller", 30.0f);
+                }
                 Abandon = true;
                 return;
             }
-            // If this is not an order...
-            if (objectiveManager.CurrentOrder != this)
-            {
-                // Don't allow to operate an item that someone with a better skills already operates
-                if (HumanAIController.IsItemOperatedByAnother(target, out _))
-                {
-                    // Don't abandon
-                    return;
-                }
-                if (component.Item.IgnoreByAI || (useController && controller.Item.IgnoreByAI))
-                {
-                    Abandon = true;
-                    return;
-                }
-            }
             if (operateTarget != null)
             {
                 if (HumanAIController.IsTrueForAnyCrewMember(other => other != HumanAIController && other.ObjectiveManager.GetActiveObjective() is AIObjectiveOperateItem operateObjective && operateObjective.operateTarget == operateTarget))
@@ -215,7 +218,7 @@ namespace Barotrauma
                     Abandon = true;
                     return;
                 }
-                else if (!character.Inventory.Items.Contains(component.Item))
+                else if (!character.Inventory.Contains(component.Item))
                 {
                     TryAddSubObjective(ref getItemObjective, () => new AIObjectiveGetItem(character, component.Item, objectiveManager, equip: true),
                         onAbandon: () => Abandon = true,
@@ -241,13 +244,14 @@ namespace Barotrauma
                                 continue;
                             }
                             //equip slot already taken
-                            if (character.Inventory.Items[i] != null)
+                            var existingItem = character.Inventory.GetItemAt(i);
+                            if (existingItem != null)
                             {
                                 //try to put the item in an Any slot, and drop it if that fails
-                                if (!character.Inventory.Items[i].AllowedSlots.Contains(InvSlotType.Any) ||
-                                    !character.Inventory.TryPutItem(character.Inventory.Items[i], character, new List<InvSlotType>() { InvSlotType.Any }))
+                                if (!existingItem.AllowedSlots.Contains(InvSlotType.Any) ||
+                                    !character.Inventory.TryPutItem(existingItem, character, new List<InvSlotType>() { InvSlotType.Any }))
                                 {
-                                    character.Inventory.Items[i].Drop(character);
+                                    existingItem.Drop(character);
                                 }
                             }
                             if (character.Inventory.TryPutItem(component.Item, i, true, false, character))

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

@@ -28,7 +28,7 @@ namespace Barotrauma
         {
             if (pump == null) { return false; }
             if (pump.Item.IgnoreByAI) { return false; }
-            if (pump.Item.NonInteractable) { return false; }
+            if (!pump.Item.IsInteractable(character)) { return false; }
             if (pump.Item.HasTag("ballast")) { return false; }
             if (pump.Item.Submarine == null) { return false; }
             if (pump.Item.CurrentHull == null) { return false; }

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

@@ -33,10 +33,14 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
-            if (!IsAllowed)
+            if (!IsAllowed || Item.IgnoreByAI)
             {
                 Priority = 0;
                 Abandon = true;
+                if (IsRepairing())
+                {
+                    Item.Repairables.ForEach(r => r.StopRepairing(character));
+                }
                 return Priority;
             }
             // TODO: priority list?
@@ -55,13 +59,13 @@ namespace Barotrauma
                     float dist = Math.Abs(character.WorldPosition.X - Item.WorldPosition.X) + yDist;
                     distanceFactor = MathHelper.Lerp(1, 0.25f, MathUtils.InverseLerp(0, 4000, dist));
                 }
-                float requiredSuccessFactor = objectiveManager.IsCurrentOrder<AIObjectiveRepairItems>() ? 0 : AIObjectiveRepairItems.RequiredSuccessFactor;
+                float requiredSuccessFactor = objectiveManager.HasOrder<AIObjectiveRepairItems>() ? 0 : AIObjectiveRepairItems.RequiredSuccessFactor;
                 float severity = isPriority ? 1 : AIObjectiveRepairItems.GetTargetPriority(Item, character, requiredSuccessFactor) / 100;
                 bool isSelected = IsRepairing();
                 float selectedBonus = isSelected ? 100 - MaxDevotion : 0;
                 float devotion = (CumulatedDevotion + selectedBonus) / 100;
                 float reduction = isPriority ? 1 : isSelected ? 2 : 3;
-                float max = MathHelper.Min(AIObjectiveManager.OrderPriority - reduction, 90);
+                float max = AIObjectiveManager.LowestOrderPriority - reduction;
                 Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (severity * distanceFactor * PriorityModifier), 0, 1));
             }
             return Priority;
@@ -70,7 +74,7 @@ namespace Barotrauma
         protected override bool Check()
         {
             IsCompleted = Item.IsFullCondition;
-            if (IsCompleted && IsRepairing())
+            if (character.IsOnPlayerTeam && IsCompleted && IsRepairing())
             {
                 character.Speak(TextManager.GetWithVariable("DialogItemRepaired", "[itemname]", Item.Name, true), null, 0.0f, "itemrepaired", 10.0f);
             }
@@ -93,7 +97,10 @@ namespace Barotrauma
                             var getItemObjective = new AIObjectiveGetItem(character, requiredItem.Identifiers, objectiveManager, true);
                             if (objectiveManager.IsCurrentOrder<AIObjectiveRepairItems>())
                             {
-                                getItemObjective.Abandoned += () => character.Speak(TextManager.Get("dialogcannotfindrequireditemtorepair"), null, 0.0f, "dialogcannotfindrequireditemtorepair", 10.0f);
+                                if (character.IsOnPlayerTeam)
+                                {
+                                    getItemObjective.Abandoned += () => character.Speak(TextManager.Get("dialogcannotfindrequireditemtorepair"), null, 0.0f, "dialogcannotfindrequireditemtorepair", 10.0f);
+                                }
                             }
                             subObjectives.Add(getItemObjective);
                         }
@@ -107,8 +114,7 @@ namespace Barotrauma
             }
             if (repairTool != null)
             {
-                var containedItems = repairTool.Item.OwnInventory?.Items;
-                if (containedItems == null)
+                if (repairTool.Item.OwnInventory == null)
                 {
 #if DEBUG
                     DebugConsole.ThrowError($"{character.Name}: AIObjectiveRepairItem failed - the item \"" + repairTool + "\" has no proper inventory");
@@ -116,27 +122,20 @@ namespace Barotrauma
                     Abandon = true;
                     return;
                 }
-                // Drop empty tanks
-                foreach (Item containedItem in containedItems)
-                {
-                    if (containedItem == null) { continue; }
-                    if (containedItem.Condition <= 0.0f)
-                    {
-                        containedItem.Drop(character);
-                    }
-                }
+                // Eject empty tanks
+                HumanAIController.UnequipEmptyItems(repairTool.Item);
                 RelatedItem item = null;
                 Item fuel = null;
                 foreach (RelatedItem requiredItem in repairTool.requiredItems[RelatedItem.RelationType.Contained])
                 {
                     item = requiredItem;
-                    fuel = containedItems.FirstOrDefault(it => it != null && it.Condition > 0.0f && requiredItem.MatchesItem(it));
+                    fuel = repairTool.Item.OwnInventory.AllItems.FirstOrDefault(it => it.Condition > 0.0f && requiredItem.MatchesItem(it));
                     if (fuel != null) { break; }
                 }
                 if (fuel == null)
                 {
                     RemoveSubObjective(ref goToObjective);
-                    TryAddSubObjective(ref refuelObjective, () => new AIObjectiveContainItem(character, item.Identifiers, repairTool.Item.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC), 
+                    TryAddSubObjective(ref refuelObjective, () => new AIObjectiveContainItem(character, item.Identifiers, repairTool.Item.GetComponent<ItemContainer>(), objectiveManager, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC), 
                         onCompleted: () => RemoveSubObjective(ref refuelObjective),
                         onAbandon: () => Abandon = true);
                     return;
@@ -178,7 +177,7 @@ namespace Barotrauma
                     }
                     if (Abandon)
                     {
-                        if (IsRepairing())
+                        if (character.IsOnPlayerTeam && IsRepairing())
                         {
                             character.Speak(TextManager.GetWithVariable("DialogCannotRepair", "[itemname]", Item.Name, true), null, 0.0f, "cannotrepair", 10.0f);
                         }
@@ -213,7 +212,7 @@ namespace Barotrauma
                     onAbandon: () =>
                     {
                         Abandon = true;
-                        if (IsRepairing())
+                        if (character.IsOnPlayerTeam && IsRepairing())
                         {
                             character.Speak(TextManager.GetWithVariable("DialogCannotRepair", "[itemname]", Item.Name, true), null, 0.0f, "cannotrepair", 10.0f);
                         }
@@ -229,7 +228,7 @@ namespace Barotrauma
                 {
                     foreach (RelatedItem requiredItem in kvp.Value)
                     {
-                        foreach (var item in character.Inventory.Items)
+                        foreach (var item in character.Inventory.AllItems)
                         {
                             if (requiredItem.MatchesItem(item))
                             {

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

@@ -104,7 +104,7 @@ namespace Barotrauma
             }
             bool anyFixers = otherFixers > 0;
             float ratio = anyFixers ? items / (float)otherFixers : 1;
-            if (objectiveManager.CurrentOrder == this)
+            if (objectiveManager.IsOrder(this))
             {
                 return Targets.Sum(t => 100 - t.ConditionPercentage);
             }
@@ -149,7 +149,7 @@ namespace Barotrauma
         {
             if (item == null) { return false; }
             if (item.IgnoreByAI) { return false; }
-            if (item.NonInteractable) { return false; }
+            if (!item.IsInteractable(character)) { return false; }
             if (item.IsFullCondition) { return false; }
             if (item.CurrentHull == null) { return false; }
             if (item.Submarine == null || character.Submarine == null) { return false; }

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

@@ -85,7 +85,7 @@ namespace Barotrauma
                             Item suit = suits.FirstOrDefault();
                             if (suit != null)
                             {
-                                AIObjectiveFindDivingGear.DropEmptyTanks(character, suit, out _);
+                                AIObjectiveFindDivingGear.EjectEmptyTanks(character, suit, out _);
                             }
                         }
                         else if (HumanAIController.HasItem(targetCharacter, AIObjectiveFindDivingGear.LIGHT_DIVING_GEAR, out IEnumerable<Item> masks, requireEquipped: true))
@@ -93,7 +93,7 @@ namespace Barotrauma
                             Item mask = masks.FirstOrDefault();
                             if (mask != null)
                             {
-                                AIObjectiveFindDivingGear.DropEmptyTanks(character, mask, out _);
+                                AIObjectiveFindDivingGear.EjectEmptyTanks(character, mask, out _);
                             }
                         }
                         bool ShouldRemoveDivingSuit() => targetCharacter.OxygenAvailable < CharacterHealth.InsufficientOxygenThreshold && targetCharacter.CurrentHull?.LethalPressure <= 0;
@@ -101,7 +101,7 @@ namespace Barotrauma
                         {
                             suits.ForEach(suit => suit.Drop(character));
                         }
-                        else if (suits.Any() && suits.None(s => s.OwnInventory?.Items != null && s.OwnInventory.Items.Any(it => it != null && it.HasTag(AIObjectiveFindDivingGear.OXYGEN_SOURCE) && it.ConditionPercentage > 0)))
+                        else if (suits.Any() && suits.None(s => s.OwnInventory?.AllItems != null && s.OwnInventory.AllItems.Any(it => it.HasTag(AIObjectiveFindDivingGear.OXYGEN_SOURCE) && it.ConditionPercentage > 0)))
                         {
                             // The target has a suit equipped with an empty oxygen tank.
                             // Can't remove the suit, because the target needs it.
@@ -322,7 +322,7 @@ namespace Barotrauma
                         {
                             itemListStr = string.Join(" or ", string.Join(", ", itemNameList.Take(itemNameList.Count - 1)), itemNameList.Last());
                         }
-                        if (targetCharacter != character)
+                        if (targetCharacter != character && character.IsOnPlayerTeam)
                         {
                             character.Speak(TextManager.GetWithVariables("DialogListRequiredTreatments", new string[2] { "[targetname]", "[treatmentlist]" },
                                 new string[2] { targetCharacter.Name, itemListStr }, new bool[2] { false, true }),
@@ -331,9 +331,16 @@ namespace Barotrauma
                         character.DeselectCharacter();
                         RemoveSubObjective(ref getItemObjective);
                         TryAddSubObjective(ref getItemObjective,
-                            constructor: () => new AIObjectiveGetItem(character, suitableItemIdentifiers.ToArray(), objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC),
+                            constructor: () => new AIObjectiveGetItem(character, suitableItemIdentifiers.ToArray(), objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == CharacterTeamType.FriendlyNPC),
                             onCompleted: () => RemoveSubObjective(ref getItemObjective),
-                            onAbandon: () => RemoveSubObjective(ref getItemObjective));
+                            onAbandon: () =>
+                            {
+                                Abandon = true;
+                                if (character != targetCharacter && character.IsOnPlayerTeam)
+                                {
+                                    character.Speak(TextManager.GetWithVariable("dialogcannottreatpatient", "[name]", targetCharacter.DisplayName, formatCapitals: false), identifier: "cannottreatpatient", minDurationBetweenSimilar: 20.0f);
+                                }
+                            });
                     }
                 }
             }
@@ -380,7 +387,7 @@ namespace Barotrauma
                 return false;
             }
             bool isCompleted = AIObjectiveRescueAll.GetVitalityFactor(targetCharacter) >= AIObjectiveRescueAll.GetVitalityThreshold(objectiveManager, character, targetCharacter);
-            if (isCompleted && targetCharacter != character)
+            if (isCompleted && targetCharacter != character && character.IsOnPlayerTeam)
             {                
                 character.Speak(TextManager.GetWithVariable("DialogTargetHealed", "[targetname]", targetCharacter.Name),
                     null, 1.0f, "targethealed" + targetCharacter.Name, 60.0f);
@@ -427,6 +434,13 @@ namespace Barotrauma
             replaceOxygenObjective = null;
             safeHull = null;
             ignoreOxygen = false;
+            character.SelectedCharacter = null;
+        }
+
+        public override void OnDeselected()
+        {
+            character.SelectedCharacter = null;
+            base.OnDeselected();
         }
     }
 }

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

@@ -14,7 +14,7 @@ namespace Barotrauma
         public override bool AllowInAnySub => true;
 
         private const float vitalityThreshold = 75;
-        private const float vitalityThresholdForOrders = 85;
+        private const float vitalityThresholdForOrders = 90;
         public static float GetVitalityThreshold(AIObjectiveManager manager, Character character, Character target)
         {
             if (manager == null)
@@ -23,7 +23,10 @@ namespace Barotrauma
             }
             else
             {
-                return character == target || manager.CurrentOrder is AIObjectiveRescueAll ? vitalityThresholdForOrders : vitalityThreshold;
+                // When targeting player characters, always treat them when ordered, else use the threshold so that minor/non-severe damage is ignored.
+                // If we ignore any damage when the player orders a bot to do healings, it's observed to cause confusion among the players.
+                // On the other hand, if the bots too eagerly heal characters when it's not nevessary, it's inefficient and can feel frustrating, because it can't be controlled.
+                return character == target || manager.CurrentOrder is AIObjectiveRescueAll ? (target.IsPlayer ? 100 : vitalityThresholdForOrders) : vitalityThreshold;
             }
         }
         
@@ -37,7 +40,7 @@ namespace Barotrauma
         protected override float TargetEvaluation()
         {
             if (Targets.None()) { return 100; }
-            if (objectiveManager.CurrentOrder != this)
+            if (!objectiveManager.IsOrder(this))
             {
                 if (!character.IsMedic && HumanAIController.IsTrueForAnyCrewMember(c => c != HumanAIController && c.Character.IsMedic && !c.Character.IsUnconscious))
                 {

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

@@ -19,27 +19,62 @@ namespace Barotrauma
 
     struct OrderInfo
     {
-        public string ComponentIdentifier { get; set; }
-        public Order Order { get; private set; }
-        public string OrderOption { get; private set; }
+        public Order Order { get; }
+        public string OrderOption { get; }
+        public int ManualPriority { get; }
+        public OrderType Type { get; }
+        public AIObjective Objective { get; }
+        public bool IsCurrentOrder => Type == OrderType.Current;
 
-        public OrderInfo(Order order, string orderOption)
+        public enum OrderType
+        {
+            Current,
+            Previous
+        }
+
+        private OrderInfo(Order order, string orderOption, int manualPriority, OrderType orderType, AIObjective objective)
         {
-            ComponentIdentifier = "currentorder";
             Order = order;
             OrderOption = orderOption;
+            ManualPriority = Math.Min(manualPriority, CharacterInfo.HighestManualOrderPriority);
+            Type = orderType;
+            Objective = objective;
         }
 
-        public OrderInfo(OrderInfo orderInfo)
-        {
-            ComponentIdentifier = "previousorder";
-            Order = orderInfo.Order;
-            OrderOption = orderInfo.OrderOption;
-        }
+        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) { }
+
+        public OrderInfo(OrderInfo orderInfo, int manualPriority) : this(orderInfo.Order, orderInfo.OrderOption, manualPriority, orderInfo.Type, orderInfo.Objective) { }
+
+        public OrderInfo(OrderInfo orderInfo, OrderType type) : this(orderInfo.Order, orderInfo.OrderOption, orderInfo.ManualPriority, type, orderInfo.Objective) { }
+
+        public bool MatchesOrder(string orderIdentifier, string orderOption) =>
+            (orderIdentifier == Order?.Identifier || (string.IsNullOrEmpty(orderIdentifier) && string.IsNullOrEmpty(Order?.Identifier))) &&
+            (orderOption == OrderOption || (string.IsNullOrEmpty(orderOption) && string.IsNullOrEmpty(OrderOption)));
 
         public bool MatchesOrder(Order order, string option) =>
-            order.Identifier == Order.Identifier &&
-            option == OrderOption;
+            MatchesOrder(order?.Identifier, option);
+
+        public bool MatchesOrder(OrderInfo orderInfo) =>
+            MatchesOrder(orderInfo.Order?.Identifier, orderInfo.OrderOption);
+
+        public bool MatchesDismissedOrder(string dismissOrderOption)
+        {
+            string[] dismissedOrder = dismissOrderOption?.Split('.');
+            if (dismissedOrder != null && dismissedOrder.Length > 0)
+            {
+                string dismissedOrderIdentifier = dismissedOrder.Length > 0 ? dismissedOrder[0] : null;
+                if (dismissedOrderIdentifier == null || dismissedOrderIdentifier != Order?.Identifier) { return false; }
+                string dismissedOrderOption = dismissedOrder.Length > 1 ? dismissedOrder[1] : null;
+                if (dismissedOrderOption == null && string.IsNullOrEmpty(OrderOption)) { return true; }
+                return dismissedOrderOption == OrderOption;
+            }
+            else
+            {
+                return false;
+            }
+        }
     }
 
     class Order
@@ -59,6 +94,10 @@ namespace Barotrauma
         public Order Prefab { get; private set; }
 
         public readonly string Name;
+        /// <summary>
+        /// Name that can be used with the contextual version of the order
+        /// </summary>
+        public readonly string ContextualName;
 
         public readonly Sprite SymbolSprite;
 
@@ -97,7 +136,6 @@ namespace Barotrauma
         public bool TargetAllCharacters { get; }
         public bool IsReport => TargetAllCharacters && !MustSetTarget;
 
-
         public readonly float FadeOutTime;
 
         public Entity TargetEntity;
@@ -119,9 +157,9 @@ namespace Barotrauma
         private readonly Dictionary<string, Sprite> minimapIcons;
         public Dictionary<string, Sprite> MinimapIcons => IsPrefab ? minimapIcons : Prefab.minimapIcons;
 
-        public readonly float Weight;
         public readonly bool MustSetTarget;
         public readonly string AppropriateSkill;
+        public readonly bool Hidden;
 
         public bool HasOptions => (IsPrefab ? Options : Prefab.Options).Length > 1;
         public bool IsPrefab { get; private set; }
@@ -159,6 +197,11 @@ namespace Barotrauma
         public int? WallSectionIndex { get; }
         public bool IsIgnoreOrder { get; }
 
+        /// <summary>
+        /// Should the order icon be drawn when the order target is inside a container
+        /// </summary>
+        public bool DrawIconWhenContained { get; }
+
         public static void Init()
         {
             Prefabs = new Dictionary<string, Order>();
@@ -239,7 +282,8 @@ namespace Barotrauma
         private Order(XElement orderElement)
         {
             Identifier = orderElement.GetAttributeString("identifier", "");
-            Name = TextManager.Get("OrderName." + Identifier, true) ?? "Name not found";
+            Name = TextManager.Get("OrderName." + Identifier, returnNull: true) ?? "Name not found";
+            ContextualName = TextManager.Get("OrderNameContextual." + Identifier, returnNull: true) ?? Name;
 
             string targetItemType = orderElement.GetAttributeString("targetitemtype", "");
             if (!string.IsNullOrWhiteSpace(targetItemType))
@@ -267,6 +311,7 @@ namespace Barotrauma
             if (!string.IsNullOrWhiteSpace(category)) { this.Category = (OrderCategory)Enum.Parse(typeof(OrderCategory), category, true); }
             MustSetTarget = orderElement.GetAttributeBool("mustsettarget", false);
             AppropriateSkill = orderElement.GetAttributeString("appropriateskill", null);
+            Hidden = orderElement.GetAttributeBool("hidden", false);
 
             var optionNames = TextManager.Get("OrderOptions." + Identifier, true)?.Split(',', '，') ??
                 orderElement.GetAttributeStringArray("optionnames", new string[0]);
@@ -315,6 +360,7 @@ namespace Barotrauma
             IsPrefab = true;
             MustManuallyAssign = orderElement.GetAttributeBool("mustmanuallyassign", false);
             IsIgnoreOrder = Identifier == "ignorethis" || Identifier == "unignorethis";
+            DrawIconWhenContained = orderElement.GetAttributeBool("displayiconwhencontained", false);
         }
 
         /// <summary>
@@ -324,23 +370,26 @@ namespace Barotrauma
         {
             Prefab = prefab.Prefab ?? prefab;
 
-            Name                = prefab.Name;
-            Identifier          = prefab.Identifier;
-            ItemComponentType   = prefab.ItemComponentType;
-            CanTypeBeSubclass   = prefab.CanTypeBeSubclass;
-            TargetItems         = prefab.TargetItems;
-            Options             = prefab.Options;
-            SymbolSprite        = prefab.SymbolSprite;
-            Color               = prefab.Color;
-            UseController       = prefab.UseController;
-            TargetAllCharacters = prefab.TargetAllCharacters;
-            AppropriateJobs     = prefab.AppropriateJobs;
-            FadeOutTime         = prefab.FadeOutTime;
-            MustSetTarget       = prefab.MustSetTarget;
-            AppropriateSkill    = prefab.AppropriateSkill;
-            Category            = prefab.Category;
-            MustManuallyAssign  = prefab.MustManuallyAssign;
-            IsIgnoreOrder       = prefab.IsIgnoreOrder;
+            Name                  = prefab.Name;
+            ContextualName        = prefab.ContextualName;
+            Identifier            = prefab.Identifier;
+            ItemComponentType     = prefab.ItemComponentType;
+            CanTypeBeSubclass     = prefab.CanTypeBeSubclass;
+            TargetItems           = prefab.TargetItems;
+            Options               = prefab.Options;
+            SymbolSprite          = prefab.SymbolSprite;
+            Color                 = prefab.Color;
+            UseController         = prefab.UseController;
+            TargetAllCharacters   = prefab.TargetAllCharacters;
+            AppropriateJobs       = prefab.AppropriateJobs;
+            FadeOutTime           = prefab.FadeOutTime;
+            MustSetTarget         = prefab.MustSetTarget;
+            AppropriateSkill      = prefab.AppropriateSkill;
+            Category              = prefab.Category;
+            MustManuallyAssign    = prefab.MustManuallyAssign;
+            IsIgnoreOrder         = prefab.IsIgnoreOrder;
+            DrawIconWhenContained = prefab.DrawIconWhenContained;
+            Hidden                = prefab.Hidden;
 
             OrderGiver = orderGiver;
             TargetEntity = targetEntity;
@@ -351,9 +400,7 @@ namespace Barotrauma
                     ConnectedController = targetItem.Item?.FindController();
                     if (ConnectedController == null)
                     {
-#if DEBUG
-                        throw new Exception("Tried to use controller, but couldn't find one");
-#endif
+                        DebugConsole.AddWarning("AI: Tried to use a controller for operating an item, but couldn't find any.");
                         UseController = false;
                     }
                 }
@@ -400,7 +447,7 @@ namespace Barotrauma
             orderOption ??= "";
 
             string messageTag = (givingOrderToSelf && !TargetAllCharacters ? "OrderDialogSelf." : "OrderDialog.") + Identifier;
-            if (!string.IsNullOrEmpty(orderOption)) { messageTag += "." + orderOption; }
+            if (Identifier != "dismissed" && !string.IsNullOrEmpty(orderOption)) { messageTag += "." + orderOption; }
 
             if (targetCharacterName == null) { targetCharacterName = ""; }
             if (targetRoomName == null) { targetRoomName = ""; }
@@ -433,7 +480,8 @@ namespace Barotrauma
             return firstMatchingComponent != null;
         }
 
-        public List<Item> GetMatchingItems(Submarine submarine, bool mustBelongToPlayerSub, Character.TeamType? requiredTeam = null)
+        /// <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)
         {
             List<Item> matchingItems = new List<Item>();
             if (submarine == null) { return matchingItems; }
@@ -456,16 +504,23 @@ namespace Barotrauma
                 {
                     matchingItems.RemoveAll(i => i.Components.None(c => c.GetType() == ItemComponentType) && !i.TryFindController(out _));
                 }
+                if (interactableFor != null)
+                {
+                    matchingItems.RemoveAll(it => !it.IsInteractable(interactableFor) ||
+                        (UseController && it.FindController() is Controller c && !c.Item.IsInteractable(interactableFor)));
+                }
             }
             return matchingItems;
         }
 
-        public List<Item> GetMatchingItems(bool mustBelongToPlayerSub)
+
+        /// <param name="interactableFor">Only returns items which are interactable for this character</param>
+        public List<Item> GetMatchingItems(bool mustBelongToPlayerSub, Character interactableFor = null)
         {
-            Submarine submarine = Character.Controlled != null && Character.Controlled.TeamID == Character.TeamType.Team2 && Submarine.MainSubs.Length > 1 ?
+            Submarine submarine = Character.Controlled != null && Character.Controlled.TeamID == CharacterTeamType.Team2 && Submarine.MainSubs.Length > 1 ?
                 Submarine.MainSubs[1] :
                 Submarine.MainSub;
-            return GetMatchingItems(submarine, mustBelongToPlayerSub);
+            return GetMatchingItems(submarine, mustBelongToPlayerSub, interactableFor: interactableFor);
         }
 
         public string GetOptionName(string id)
@@ -478,5 +533,23 @@ namespace Barotrauma
             if (index < 0 || index >= Options.Length) { return null; }
             return GetOptionName(Options[index]);
         }
+
+        /// <summary>
+        /// Used to create the order option for the Dismiss order to know which order it targets
+        /// </summary>
+        /// <param name="orderInfo">The order to target with the dismiss order</param>
+        public static string GetDismissOrderOption(OrderInfo orderInfo)
+        {
+            if (orderInfo.Order != null)
+            {
+                string option = orderInfo.Order.Identifier;
+                if (!string.IsNullOrEmpty(orderInfo.OrderOption))
+                {
+                    option += $".{orderInfo.OrderOption}";
+                }
+                return option;
+            }
+            return "";
+        }
     }
 }

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

@@ -254,11 +254,8 @@ namespace Barotrauma
         {
             if (AiController.Character.Inventory != null)
             {
-                var items = AiController.Character.Inventory.Items;
-                for (int i = 0; i < items.Length; i++)
+                foreach (Item item in AiController.Character.Inventory.AllItems)
                 {
-                    var item = items[i];
-                    if (item == null) { continue; }
                     var tag = item.GetComponent<NameTag>();
                     if (tag != null && !string.IsNullOrWhiteSpace(tag.WrittenName))
                     {
@@ -358,7 +355,7 @@ namespace Barotrauma
 
                 XElement petElement = new XElement("pet", 
                     new XAttribute("speciesname", c.SpeciesName), 
-                    new XAttribute("ownerid", petBehavior.Owner?.ID ?? Entity.NullEntityID),
+                    new XAttribute("ownerhash", petBehavior.Owner?.Info?.GetIdentifier() ?? 0),
                     new XAttribute("seed", c.Seed));
 
                 var petBehaviorElement = new XElement("petbehavior",
@@ -387,16 +384,19 @@ namespace Barotrauma
             {
                 string speciesName = subElement.GetAttributeString("speciesname", "");
                 string seed = subElement.GetAttributeString("seed", "123");
-                ushort ownerID = (ushort)subElement.GetAttributeInt("ownerid", 0);
+                int ownerHash = subElement.GetAttributeInt("ownerhash", 0);
                 Vector2 spawnPos = Vector2.Zero;
-                Character owner = Entity.FindEntityByID(ownerID) as Character;
-                if (owner != null)
+                Character owner = Character.CharacterList.Find(c => c.Info?.GetIdentifier() == ownerHash);
+                if (owner != null && owner.Submarine?.Info.Type == SubmarineType.Player)
                 {
                     spawnPos = owner.WorldPosition;
                 }
                 else
                 {
-                    var spawnPoint = WayPoint.WayPointList.Where(wp => wp.SpawnType == SpawnType.Human && wp.Submarine?.Info.Type == SubmarineType.Player).GetRandom();
+                    //try to find a spawnpoint in the main sub
+                    var spawnPoint = WayPoint.WayPointList.Where(wp => wp.SpawnType == SpawnType.Human && wp.Submarine == Submarine.MainSub).GetRandom();
+                    //if not found, try any player sub (shuttle/drone etc)
+                    spawnPoint ??= WayPoint.WayPointList.Where(wp => wp.SpawnType == SpawnType.Human && wp.Submarine?.Info.Type == SubmarineType.Player).GetRandom();
                     spawnPos = spawnPoint?.WorldPosition ?? Submarine.MainSub.WorldPosition;
                 }
                 var pet = Character.Create(speciesName, spawnPos, seed);

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

@@ -94,20 +94,24 @@ namespace Barotrauma
         {
             Vector2 targetVel = target - host.SimPosition;
 
-            if (targetVel.LengthSquared() < 0.00001f) return Vector2.Zero;
+            if (targetVel.LengthSquared() < 0.00001f) { return Vector2.Zero; }
 
             targetVel = Vector2.Normalize(targetVel) * weight;
-            Vector2 newSteering = targetVel - host.Steering;
+            // TODO: the code below doesn't quite work as it should, and I'm not sure what the purpose of it is/was.
+            // So, we'll just return the targetVel for now, as it produces smooth results.
+            return targetVel;
 
-            if (newSteering == Vector2.Zero) return Vector2.Zero;
+            //Vector2 newSteering = targetVel - host.Steering;
 
-            float steeringSpeed = (newSteering + host.Steering).Length();
-            if (steeringSpeed > Math.Abs(weight))
-            {
-                newSteering = Vector2.Normalize(newSteering) * Math.Abs(weight);
-            }
+            //if (newSteering == Vector2.Zero) return Vector2.Zero;
 
-            return newSteering;
+            //float steeringSpeed = (newSteering + host.Steering).Length();
+            //if (steeringSpeed > Math.Abs(weight))
+            //{
+            //    newSteering = Vector2.Normalize(newSteering) * Math.Abs(weight);
+            //}
+
+            //return newSteering;
         }
 
         protected virtual Vector2 DoSteeringWander(float weight)

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

@@ -35,7 +35,7 @@ namespace Barotrauma
 
         private static IEnumerable<MapEntity> GetThalamusEntities(Submarine wreck, string tag) => MapEntity.mapEntityList.Where(e => e.Submarine == wreck && e.prefab != null && IsThalamus(e.prefab, tag));
 
-        private static bool IsThalamus(MapEntityPrefab entityPrefab, string tag) => entityPrefab.Category == MapEntityCategory.Thalamus || entityPrefab.Tags.Contains(tag);
+        private static bool IsThalamus(MapEntityPrefab entityPrefab, string tag) => entityPrefab.HasSubCategory("thalamus") || entityPrefab.Tags.Contains(tag);
 
         public WreckAI(Submarine wreck)
         {
@@ -131,7 +131,7 @@ namespace Barotrauma
                             if (container == null) { continue; }
                             for (int i = 0; i < container.Inventory.Capacity; i++)
                             {
-                                if (container.Inventory.Items[i] != null) { continue; }
+                                if (container.Inventory.GetItemAt(i) != null) { continue; }
                                 if (MapEntityPrefab.List.GetRandom(e => e is ItemPrefab i && container.CanBeContained(i) && 
                                         Config.ForbiddenAmmunition.None(id => id.Equals(i.Identifier, StringComparison.OrdinalIgnoreCase)), Rand.RandSync.Server) is ItemPrefab ammoPrefab)
                                 {
@@ -246,7 +246,7 @@ namespace Barotrauma
             initialCellsSpawned = true;
         }
 
-        private void Kill()
+        public void Kill()
         {
             thalamusItems.ForEach(i => i.Condition = 0);
             foreach (var turret in turrets)
@@ -319,25 +319,33 @@ namespace Barotrauma
         private readonly List<Hull> populatedHulls = new List<Hull>();
         private float cellSpawnTimer;
 
-        private float CellSpawnTime => Config.AgentSpawnDelay;
-        private float CellSpawnRandomFactor => Config.AgentSpawnDelayRandomFactor;
-        private int MinCellsPerBrainRoom => Config.MinAgentsPerBrainRoom;
-        private int MaxCellsPerRoom => Config.MaxAgentsPerRoom;
-        private int MinCellsOutside => Config.MinAgentsOutside;
-        private int MaxCellsOutside => Config.MaxAgentsOutside;
-        private int MinCellsInside => Config.MinAgentsInside;
-        private int MaxCellsInside => Config.MaxAgentsInside;
-        private int MaxCellCount => Config.MaxAgentCount;
+        private int MinCellsPerBrainRoom => CalculateCellCount(0, Config.MinAgentsPerBrainRoom);
+        private int MaxCellsPerRoom => CalculateCellCount(1, Config.MaxAgentsPerRoom);
+        private int MinCellsOutside => CalculateCellCount(0, Config.MinAgentsOutside);
+        private int MaxCellsOutside => CalculateCellCount(0, Config.MaxAgentsOutside);
+        private int MinCellsInside => CalculateCellCount(2, Config.MinAgentsInside);
+        private int MaxCellsInside => CalculateCellCount(3, Config.MaxAgentsInside);
+        private int MaxCellCount => CalculateCellCount(5, Config.MaxAgentCount);
         private float MinWaterLevel => Config.MinWaterLevel;
 
+        private int CalculateCellCount(int minValue, int maxValue)
+        {
+            if (maxValue == 0) { return 0; }
+            return (int)Math.Round(MathHelper.Lerp(minValue, maxValue, Level.Loaded.Difficulty * 0.01f * Config.AgentSpawnCountDifficultyMultiplier));
+        }
+
+        private float GetSpawnTime() => 
+            Math.Max(Config.AgentSpawnDelay * Rand.Range(Config.AgentSpawnDelayRandomFactor, 1 + Config.AgentSpawnDelayRandomFactor) 
+            / (Math.Max(Level.Loaded.Difficulty, 1) * 0.01f * Config.AgentSpawnDelayDifficultyMultiplier), Config.AgentSpawnDelay);
+
         void UpdateReinforcements(float deltaTime)
         {
-            if (protectiveCells.Count >= MaxCellCount || spawnOrgans.Count == 0) { return; }
+            if (spawnOrgans.Count == 0) { return; }
             cellSpawnTimer -= deltaTime;
             if (cellSpawnTimer < 0)
             {
                 TrySpawnCell(out _, spawnOrgans.GetRandom());
-                cellSpawnTimer = CellSpawnTime * Rand.Range(CellSpawnRandomFactor, 1 + CellSpawnRandomFactor);
+                cellSpawnTimer = GetSpawnTime();
             }
         }
 
@@ -364,7 +372,7 @@ namespace Barotrauma
             cell = Character.Create(Config.DefensiveAgent, targetEntity.WorldPosition, ToolBox.RandomSeed(8), hasAi: true, createNetworkEvent: true);
             protectiveCells.Add(cell);
             cell.OnDeath += OnCellDeath;
-            cellSpawnTimer = CellSpawnTime * Rand.Range(CellSpawnRandomFactor, 1 + CellSpawnRandomFactor);
+            cellSpawnTimer = GetSpawnTime();
             return true;
         }
         

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

@@ -42,6 +42,12 @@ namespace Barotrauma
         [Serialize(0.5f, false)]
         public float AgentSpawnDelayRandomFactor { get; private set; }
 
+        [Serialize(1f, false)]
+        public float AgentSpawnDelayDifficultyMultiplier { get; private set; }
+
+        [Serialize(1f, false)]
+        public float AgentSpawnCountDifficultyMultiplier { get; private set; }
+
         [Serialize(0, false)]
         public int MinAgentsPerBrainRoom { get; private set; }