Unstable v0.1300.0.0 (February 19th 2021)

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))
                 {