(965c31410a) Unstable v0.10.4.0

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

@@ -31,6 +31,7 @@ namespace Barotrauma
         public virtual bool KeepDivingGearOn => false;
         public virtual bool UnequipItems => false;
         public virtual bool AllowOutsideSubmarine => false;
+        public virtual bool AllowInFriendlySubs => false;
 
         protected readonly List<AIObjective> subObjectives = new List<AIObjective>();
         private float _cumulatedDevotion;
@@ -46,6 +47,8 @@ namespace Barotrauma
         /// Final priority value after all calculations.
         /// </summary>
         public float Priority { get; set; }
+        public float BasePriority { get; set; }
+
         public float PriorityModifier { get; private set; } = 1;
         public readonly Character character;
         public readonly AIObjectiveManager objectiveManager;
@@ -182,7 +185,18 @@ namespace Barotrauma
             }
         }
 
-        protected bool IsAllowed => AllowOutsideSubmarine || character.Submarine != null && character.Submarine.TeamID == character.TeamID && character.Submarine.Info.IsPlayer;
+        protected bool IsAllowed
+        {
+            get 
+            { 
+                if (AllowOutsideSubmarine) { return true; }
+                if (character.Submarine == null) { return false; }
+                return 
+                    character.Submarine.TeamID == character.TeamID || 
+                    (AllowInFriendlySubs && character.Submarine.TeamID == Character.TeamType.FriendlyNPC) || 
+                    character.Submarine.DockedTo.Any(sub => sub.TeamID == character.TeamID);
+            }
+        }
 
         /// <summary>
         /// Call this only when the priority needs to be recalculated. Use the cached Priority property when you don't need to recalculate.
@@ -200,7 +214,7 @@ namespace Barotrauma
             }
             else
             {
-                Priority = CumulatedDevotion;
+                Priority = BasePriority + CumulatedDevotion;
             }
             return Priority;
         }
@@ -336,7 +350,12 @@ namespace Barotrauma
             }
             protected set
             {
+                if (isCompleted == value) { return; }
                 isCompleted = value;
+                if (isCompleted)
+                {
+                    OnCompleted();
+                }
             }
         }
 
@@ -346,7 +365,7 @@ namespace Barotrauma
         {
             hasBeenChecked = true;
             CheckSubObjectives();
-            if (subObjectives.None())
+            if (subObjectives.None() || ConcurrentObjectives && subObjectives.All(so => so is AIObjectiveGoTo))
             {
                 if (Check())
                 {

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

@@ -1,9 +1,9 @@
-using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Barotrauma.Extensions;
 
 namespace Barotrauma
 {
@@ -18,13 +18,17 @@ namespace Barotrauma
         private readonly CombatMode initialMode;
 
         private float seekWeaponsTimer;
-        const float seekWeaponsInterval = 1;
+        private readonly float seekWeaponsInterval = 1;
         private float ignoreWeaponTimer;
-        const float ignoredWeaponsClearTime = 10;
+        private readonly float ignoredWeaponsClearTime = 10;
 
-        const float coolDown = 10.0f;
-        // Won't take the offensive with weapons that have lower priority than this
-        const float goodWeaponPriority = 30;
+        // Won't (by default) start the offensive with weapons that have lower priority than this
+        private readonly float goodWeaponPriority = 30;
+
+        private readonly float arrestHoldFireTime = 8;
+        private float holdFireTimer;
+        private bool hasAimed;
+        private bool isLethalWeapon;
 
         public Character Enemy { get; private set; }
         public bool HoldPosition { get; set; }
@@ -37,6 +41,7 @@ namespace Barotrauma
             {
                 _weapon = value;
                 _weaponComponent = null;
+                hasAimed = false;
                 RemoveSubObjective(ref seekAmmunition);
             }
         }
@@ -73,16 +78,36 @@ namespace Barotrauma
         private IEnumerable<FarseerPhysics.Dynamics.Body> myBodies;
         private float aimTimer;
 
+        private bool canSeeTarget;
+        private float visibilityCheckTimer;
+        private readonly float visibilityCheckInterval = 0.2f;
+
+        /// <summary>
+        /// Aborts the objective when this condition is true
+        /// </summary>
+        public Func<bool> abortCondition;
+
+        public bool allowHoldFire;
+
+        /// <summary>
+        /// Don't start using a weapon if this condition is true
+        /// </summary>
+        public Func<bool> holdFireCondition;
+
         public enum CombatMode
         {
             Defensive,
             Offensive,
+            Arrest,
             Retreat
         }
 
         public CombatMode Mode { get; private set; }
 
-        public AIObjectiveCombat(Character character, Character enemy, CombatMode mode, AIObjectiveManager objectiveManager, float priorityModifier = 1) 
+        private bool IsOffensiveOrArrest => initialMode == CombatMode.Offensive || initialMode == CombatMode.Arrest;
+        private bool TargetEliminated => Enemy == null || Enemy.Removed || Enemy.IsUnconscious;
+
+        public AIObjectiveCombat(Character character, Character enemy, CombatMode mode, AIObjectiveManager objectiveManager, float priorityModifier = 1, float coolDown = 10.0f) 
             : base(character, objectiveManager, priorityModifier)
         {
             Enemy = enemy;
@@ -103,7 +128,16 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
-            Priority = (Enemy != null && (Enemy.Removed || Enemy.IsDead)) ? 0 : Math.Min(100 * PriorityModifier, 100);
+            if (character.TeamID == Character.TeamType.FriendlyNPC && Enemy != null)
+            {
+                if (Enemy.Submarine == null || (Enemy.Submarine.TeamID != character.TeamID && Enemy.Submarine != character.Submarine))
+                {
+                    Priority = 0;
+                    return Priority;
+                }
+            }
+            float damageFactor = MathUtils.InverseLerp(0.0f, 5.0f, HumanAIController.GetDamageDoneByAttacker(Enemy) / 100.0f);
+            Priority = TargetEliminated ? 0 : Math.Min((95 + damageFactor) * PriorityModifier, 100);
             return Priority;
         }
 
@@ -121,43 +155,55 @@ namespace Barotrauma
 
         protected override bool Check()
         {
-            if (initialMode == CombatMode.Offensive && Mode != CombatMode.Offensive)
+            if (IsOffensiveOrArrest && Mode != initialMode)
             {
                 Abandon = true;
                 SteeringManager.Reset();
                 return false;
             }
-            bool completed = (Enemy != null && (Enemy.Removed || Enemy.IsDead)) || (initialMode != CombatMode.Offensive && coolDownTimer <= 0);
-            if (completed)
-            {
-                if (objectiveManager.CurrentOrder == this && Enemy != null && Enemy.IsDead)
-                {
-                    character.Speak(TextManager.Get("DialogTargetDown"), null, 3.0f, "targetdown", 30.0f);
-                }
-                if (Weapon != null)
-                {
-                    Unequip();
-                }
-            }
-            return completed;
+            return IsEnemyDisabled || (!IsOffensiveOrArrest && coolDownTimer <= 0);
         }
 
+        private bool IsEnemyDisabled => Enemy == null || Enemy.Removed || Enemy.IsDead;
+
         protected override void Act(float deltaTime)
         {
-            if (initialMode != CombatMode.Offensive)
+            if (abortCondition != null && abortCondition())
+            {
+                Abandon = true;
+                SteeringManager.Reset();
+                return;
+            }
+            if (!IsOffensiveOrArrest)
             {
                 coolDownTimer -= deltaTime;
             }
             if (seekAmmunition == null)
             {
-                if (Mode != CombatMode.Retreat && TryArm() && Enemy != null && !Enemy.Removed)
+                if (Mode != CombatMode.Retreat && TryArm() && !IsEnemyDisabled)
                 {
                     OperateWeapon(deltaTime);
                 }
-                if (!HoldPosition && seekAmmunition == null)
+                if (!HoldPosition)
                 {
                     Move(deltaTime);
                 }
+                switch (Mode)
+                {
+                    case CombatMode.Offensive:
+                        if (TargetEliminated && objectiveManager.IsCurrentOrder<AIObjectiveFightIntruders>())
+                        {
+                            // TODO: enable
+                            //character.Speak(TextManager.Get("DialogTargetDown"), null, 3.0f, "targetdown", 30.0f);
+                        }
+                        break;
+                    case CombatMode.Arrest:
+                        if (HumanAIController.HasItem(Enemy, "handlocker", out _, requireEquipped: true))
+                        {
+                            IsCompleted = true;
+                        }
+                        break;
+                }
             }
         }
 
@@ -166,6 +212,7 @@ namespace Barotrauma
             switch (Mode)
             {
                 case CombatMode.Offensive:
+                case CombatMode.Arrest:
                     Engage();
                     break;
                 case CombatMode.Defensive:
@@ -190,7 +237,7 @@ namespace Barotrauma
             {
                 seekWeaponsTimer = seekWeaponsInterval;
                 // First go through all weapons and try to reload without seeking ammunition
-                var allWeapons = GetAllWeapons().ToList();
+                var allWeapons = GetAllWeapons();
                 while (allWeapons.Any())
                 {
                     Weapon = GetWeapon(allWeapons, out _weaponComponent);
@@ -206,16 +253,6 @@ namespace Barotrauma
                         Weapon = null;
                         continue;
                     }
-                    if (initialMode == CombatMode.Offensive)
-                    {
-                        // In the offensive mode, let's ignore weapons that cannot be used in the offensive mode
-                        if (WeaponComponent.CombatPriority < goodWeaponPriority)
-                        {
-                            allWeapons.Remove(WeaponComponent);
-                            Weapon = null;
-                            continue;
-                        }
-                    }
                     if (IsLoaded(WeaponComponent))
                     {
                         // All good, the weapon is loaded
@@ -253,6 +290,10 @@ namespace Barotrauma
                         }
                     }
                 }
+                if (Weapon == null)
+                {
+                    Mode = CombatMode.Retreat;
+                }
             }
             else
             {
@@ -261,14 +302,6 @@ namespace Barotrauma
                     Weapon = null;
                 }
             }
-            if (Weapon == null)
-            {
-                Mode = CombatMode.Retreat;
-            }
-            else
-            {
-                Mode = WeaponComponent.CombatPriority >= goodWeaponPriority ? initialMode : CombatMode.Defensive;
-            }
             return Weapon != null;
 
             bool CheckWeapon(bool seekAmmo)
@@ -296,6 +329,7 @@ namespace Barotrauma
             {
                 case CombatMode.Offensive:
                 case CombatMode.Defensive:
+                case CombatMode.Arrest:
                     if (Equip())
                     {
                         Attack(deltaTime);
@@ -308,29 +342,163 @@ namespace Barotrauma
             }
         }
 
-        private Item GetWeapon(out ItemComponent weaponComponent)
-        {
-            GetAllWeapons();
-            return GetWeapon(weapons, out weaponComponent);
-        }
+        private Item GetWeapon(out ItemComponent weaponComponent) => GetWeapon(GetAllWeapons(), out weaponComponent);
 
         private Item GetWeapon(IEnumerable<ItemComponent> weaponList, out ItemComponent weaponComponent)
         {
-            weaponComponent = weaponList.OrderByDescending(w => CalculateWeaponPriority(w)).FirstOrDefault();
-            if (weaponComponent == null) { return null; }
-            if (weaponComponent.CombatPriority < 1) { return null; }
-            return weaponComponent.Item;
-        }
-
-        private float CalculateWeaponPriority(ItemComponent weapon)
-        {
-            float priority = weapon.CombatPriority;
-            // Halve the priority for weapons that don't have proper ammunition loaded.
-            if (!weapon.HasRequiredContainedItems(character, addMessage: false))
+            weaponComponent = null;
+            float bestPriority = 0;
+            float lethalDmg = -1;
+            foreach (var weapon in weaponList)
             {
-                priority /= 2;
+                // By default, the bots won't go offensive with bad weapons, unless they are close to the enemy or ordered to fight enemies.
+                // NPC characters ignore this check.
+                if ((initialMode == CombatMode.Offensive || initialMode == CombatMode.Arrest) && character.TeamID != Character.TeamType.FriendlyNPC)
+                {
+                    if (!objectiveManager.IsCurrentOrder<AIObjectiveFightIntruders>() && !EnemyIsClose())
+                    {
+                        if (weapon.CombatPriority < goodWeaponPriority)
+                        {
+                            continue;
+                        }
+                    }
+                }
+
+                float priority = weapon.CombatPriority;
+                if (!IsLoaded(weapon))
+                {
+                    if (weapon is RangedWeapon && EnemyIsClose())
+                    {
+                        // Close to the enemy. Ignore weapons that don't have any ammunition (-> Don't seek ammo).
+                        continue;
+                    }
+                    else
+                    {
+                        // Halve the priority for weapons that don't have proper ammunition loaded.
+                        priority /= 2;
+                    }
+                }
+                if (Enemy.Stun > 1)
+                {
+                    // Enemy is stunned, reduce the priority of stunner weapons.
+                    Attack attack = GetAttackDefinition(weapon);
+                    if (attack != null)
+                    {
+                        lethalDmg = attack.GetTotalDamage();
+                        float max = lethalDmg + 1;
+                        if (weapon.Item.HasTag("stunner"))
+                        {
+                            priority = max;
+                        }
+                        else
+                        {
+                            float stunDmg = ApproximateStunDamage(weapon, attack);
+                            float diff = stunDmg - lethalDmg;
+                            priority = Math.Clamp(priority - Math.Max(diff * 2, 0), min: 1, max);
+                        }
+                    }
+                }
+                else if (Mode == CombatMode.Arrest)
+                {
+                    // Enemy is not stunned, increase the priority of stunner weapons and decrease the priority of lethal weapons.
+                    if (weapon.Item.HasTag("stunner"))
+                    {
+                        priority *= 2;
+                    }
+                    else
+                    {
+                        Attack attack = GetAttackDefinition(weapon);
+                        if (attack != null)
+                        {
+                            lethalDmg = attack.GetTotalDamage();
+                            float stunDmg = ApproximateStunDamage(weapon, attack);
+                            float diff = stunDmg - lethalDmg;
+                            if (diff < 0)
+                            {
+                                priority /= 2;
+                            }
+                        }
+                    }
+                }
+                if (priority > bestPriority)
+                {
+                    weaponComponent = weapon;
+                    bestPriority = priority;
+                }
+            }
+            if (weaponComponent == null) { return null; }
+            if (bestPriority < 1) { return null; }
+            if (Mode == CombatMode.Arrest)
+            {
+                if (weaponComponent.Item.HasTag("stunner"))
+                {
+                    isLethalWeapon = false;
+                }
+                else
+                {
+                    if (lethalDmg < 0)
+                    {
+                        lethalDmg = GetLethalDamage(weaponComponent);
+                    }
+                    isLethalWeapon = lethalDmg > 1;
+                }
+                if (allowHoldFire && !hasAimed && holdFireTimer <= 0)
+                {
+                    holdFireTimer = arrestHoldFireTime * Rand.Range(0.75f, 1.25f);
+                }
+            }
+            return weaponComponent.Item;
+
+            bool EnemyIsClose() => character.CurrentHull == Enemy.CurrentHull || Vector2.DistanceSquared(character.Position, Enemy.Position) < 500;
+
+            Attack GetAttackDefinition(ItemComponent weapon)
+            {
+                Attack attack = null;
+                if (weapon is MeleeWeapon meleeWeapon)
+                {
+                    attack = meleeWeapon.Attack;
+                }
+                else if (weapon is RangedWeapon rangedWeapon)
+                {
+                    attack = rangedWeapon.FindProjectile(triggerOnUseOnContainers: false)?.Attack;
+                }
+                return attack;
+            }
+
+            float GetLethalDamage(ItemComponent weapon)
+            {
+                float lethalDmg = 0;
+                Attack attack = GetAttackDefinition(weapon);
+                if (attack != null)
+                {
+                    lethalDmg = attack.GetTotalDamage();
+                }
+                return lethalDmg;
+            }
+
+            float ApproximateStunDamage(ItemComponent weapon, Attack attack)
+            {
+                // Try to reduce the priority using the actual damage values and status effects.
+                // This is an approximation, because we can't check the status effect conditions here.
+                // The result might be incorrect if there is a high stun effect that's only applied in certain conditions.
+                var statusEffects = attack.StatusEffects.Where(se => !se.HasConditions && se.type == ActionType.OnUse && se.HasRequiredItems(character));
+                if (weapon.statusEffectLists != null && weapon.statusEffectLists.TryGetValue(ActionType.OnUse, out List<StatusEffect> hitEffects))
+                {
+                    statusEffects = statusEffects.Concat(hitEffects);
+                }
+                float afflictionsStun = attack.Afflictions.Keys.Sum(a => a.Identifier == "stun" ? a.Strength : 0);
+                float effectsStun = statusEffects.None() ? 0 : statusEffects.Max(se =>
+                {
+                    float stunAmount = 0;
+                    var stunAffliction = se.Afflictions.Find(a => a.Identifier == "stun");
+                    if (stunAffliction != null)
+                    {
+                        stunAmount = stunAffliction.Strength;
+                    }
+                    return stunAmount;
+                });
+                return attack.Stun + afflictionsStun + effectsStun;
             }
-            return priority;
         }
 
         private HashSet<ItemComponent> GetAllWeapons()
@@ -354,30 +522,9 @@ namespace Barotrauma
             if (item == null) { return; }
             foreach (var component in item.Components)
             {
-                if (component is RangedWeapon rw)
+                if (component.CombatPriority > 0)
                 {
-                    weaponList.Add(rw);
-                }
-                else if (component is MeleeWeapon mw)
-                {
-                    weaponList.Add(mw);
-                }
-                else
-                {
-                    var effects = component.statusEffectLists;
-                    if (effects != null)
-                    {
-                        foreach (var statusEffects in effects.Values)
-                        {
-                            foreach (var statusEffect in statusEffects)
-                            {
-                                if (statusEffect.Afflictions.Any())
-                                {
-                                    weaponList.Add(component);
-                                }
-                            }
-                        }
-                    }
+                    weaponList.Add(component);
                 }
             }
         }
@@ -423,11 +570,11 @@ namespace Barotrauma
 
         private void Retreat(float deltaTime)
         {
-            RemoveSubObjective(ref followTargetObjective);
+            RemoveFollowTarget();
             RemoveSubObjective(ref seekAmmunition);
             if (retreatObjective != null && retreatObjective.Target != retreatTarget)
             {
-                retreatObjective = null;
+                RemoveSubObjective(ref retreatObjective);
             }
             if (retreatTarget == null || (retreatObjective != null && !retreatObjective.CanBeCompleted))
             {
@@ -437,7 +584,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    retreatTarget = findSafety.FindBestHull(HumanAIController.VisibleHulls);
+                    retreatTarget = findSafety.FindBestHull(HumanAIController.VisibleHulls, allowChangingTheSubmarine: character.TeamID != Character.TeamType.FriendlyNPC);
                     findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
                 }
             }
@@ -454,7 +601,6 @@ namespace Barotrauma
                         }
                         else
                         {
-
                             // else abandon and fall back to find safety mode
                             Abandon = true;
                         }
@@ -476,10 +622,10 @@ namespace Barotrauma
             RemoveSubObjective(ref seekAmmunition);
             if (followTargetObjective != null && followTargetObjective.Target != Enemy)
             {
-                followTargetObjective = null;
+                RemoveFollowTarget();
             }
             TryAddSubObjective(ref followTargetObjective,
-                constructor: () => new AIObjectiveGoTo(Enemy, character, objectiveManager, repeat: true, getDivingGearIfNeeded: true)
+                constructor: () => new AIObjectiveGoTo(Enemy, character, objectiveManager, repeat: true, getDivingGearIfNeeded: true, closeEnough: 50)
                 {
                     IgnoreIfTargetDead = true,
                     DialogueIdentifier = "dialogcannotreachtarget",
@@ -490,7 +636,30 @@ namespace Barotrauma
                     Abandon = true;
                     SteeringManager.Reset();
                 });
-            if (followTargetObjective != null)
+            if (followTargetObjective == null) { return; }
+            if (Mode == CombatMode.Arrest && Enemy.Stun > 2)
+            {
+                if (HumanAIController.HasItem(character, "handlocker", out Item handCuffs))
+                {
+                    if (!arrestingRegistered)
+                    {
+                        arrestingRegistered = true;
+                        followTargetObjective.Completed += OnArrestTargetReached;
+                    }
+                    followTargetObjective.CloseEnough = 100;
+                }
+                else
+                {
+                    RemoveFollowTarget();
+                    SteeringManager.Reset();
+                }
+            }
+            else if (WeaponComponent == null)
+            {
+                RemoveFollowTarget();
+                SteeringManager.Reset();
+            }
+            else
             {
                 followTargetObjective.CloseEnough =
                     WeaponComponent is RangedWeapon ? 1000 :
@@ -499,6 +668,48 @@ namespace Barotrauma
             }
         }
 
+        private bool arrestingRegistered;
+
+        private void RemoveFollowTarget()
+        {
+            if (arrestingRegistered)
+            {
+                followTargetObjective.Completed -= OnArrestTargetReached;
+            }
+            RemoveSubObjective(ref followTargetObjective);
+            arrestingRegistered = false;
+        }
+
+        private void OnArrestTargetReached()
+        {
+            if (HumanAIController.HasItem(character, "handlocker", out Item handCuffs) && Enemy.Stun > 0 && character.CanInteractWith(Enemy))
+            {
+                if (HumanAIController.TryToMoveItem(handCuffs, Enemy.Inventory))
+                {
+                    handCuffs.Equip(Enemy);
+                }
+                else
+                {
+#if DEBUG
+                    DebugConsole.NewMessage($"{character.Name}: Failed to handcuff the target.", Color.Red);
+#endif
+                }
+                // Confiscate stolen goods.
+                foreach (var item in Enemy.Inventory.Items)
+                {
+                    if (item == null || item == handCuffs) { continue; }
+                    if (item.StolenDuringRound)
+                    {
+                        item.Drop(character);
+                        character.Inventory.TryPutItem(item, character, new List<InvSlotType>() { InvSlotType.Any });
+                    }
+                }
+                // TODO: enable
+                //character.Speak(TextManager.Get("DialogTargetArrested"), null, 3.0f, "targetarrested", 30.0f);
+                IsCompleted = true;
+            }
+        }
+
         /// <summary>
         /// Seeks for more ammunition. Creates a new subobjective.
         /// </summary>
@@ -506,7 +717,7 @@ namespace Barotrauma
         {
             retreatTarget = null;
             RemoveSubObjective(ref retreatObjective);
-            RemoveSubObjective(ref followTargetObjective);
+            RemoveFollowTarget();
             TryAddSubObjective(ref seekAmmunition,
                 constructor: () => new AIObjectiveContainItem(character, ammunitionIdentifiers, Weapon.GetComponent<ItemContainer>(), objectiveManager)
                 {
@@ -588,7 +799,7 @@ namespace Barotrauma
             {
                 return true;
             }
-            else if (ammunition == null && !HoldPosition && initialMode == CombatMode.Offensive && seekAmmo && ammunitionIdentifiers != null)
+            else if (ammunition == null && !HoldPosition && IsOffensiveOrArrest && seekAmmo && ammunitionIdentifiers != null)
             {
                 SeekAmmunition(ammunitionIdentifiers);
             }
@@ -598,46 +809,64 @@ namespace Barotrauma
         private void Attack(float deltaTime)
         {
             character.CursorPosition = Enemy.Position;
-            if (!character.CanSeeCharacter(Enemy)) { return; }
+            visibilityCheckTimer -= deltaTime;
+            if (visibilityCheckTimer <= 0.0f)
+            {
+                canSeeTarget = character.CanSeeTarget(Enemy);
+                visibilityCheckTimer = visibilityCheckInterval;
+            }
+            if (!canSeeTarget) { return; }
             if (Weapon.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);
             }
-            bool isFacing = character.AnimController.Dir > 0 && Enemy.WorldPosition.X > character.WorldPosition.X || character.AnimController.Dir < 0 && Enemy.WorldPosition.X < character.WorldPosition.X;
-            if (!isFacing)
+            hasAimed = true;
+            if (holdFireTimer > 0)
             {
-                aimTimer = Rand.Range(1f, 1.5f);
+                holdFireTimer -= deltaTime;
+                return;
             }
             if (aimTimer > 0)
             {
                 aimTimer -= deltaTime;
                 return;
             }
+            if (Mode == CombatMode.Arrest && isLethalWeapon && Enemy.Stun > 0) { return; }
+            if (holdFireCondition != null && holdFireCondition()) { return; }
+            float sqrDist = Vector2.DistanceSquared(character.Position, Enemy.Position);
+            if (!character.IsFacing(Enemy.WorldPosition))
+            {
+                aimTimer = Rand.Range(1f, 1.5f);
+                return;
+            }
             if (WeaponComponent is MeleeWeapon meleeWeapon)
             {
-                if (Vector2.DistanceSquared(character.Position, Enemy.Position) <= meleeWeapon.Range * meleeWeapon.Range)
+                float sqrRange = meleeWeapon.Range * meleeWeapon.Range;
+                if (character.AnimController.InWater)
                 {
-                    character.SetInput(InputType.Shoot, false, true);
-                    Weapon.Use(deltaTime, character);
+                    if (sqrDist > sqrRange) { return; }
                 }
+                else
+                {
+                    // It's possible that the center point of the creature is out of reach, but we could still hit the character.
+                    float xDiff = Math.Abs(Enemy.WorldPosition.X - character.WorldPosition.X);
+                    if (xDiff > meleeWeapon.Range) { return; }
+                    float yDiff = Math.Abs(Enemy.WorldPosition.Y - character.WorldPosition.Y);
+                    if (yDiff > Math.Max(meleeWeapon.Range, 100)) { return; }
+                    if (Enemy.WorldPosition.Y < character.WorldPosition.Y && yDiff > 25)
+                    {
+                        // The target is probably knocked down? -> try to reach it by crouching.
+                        HumanAIController.AnimController.Crouching = true;
+                    }
+                }
+                character.SetInput(InputType.Shoot, false, true);
+                Weapon.Use(deltaTime, character);
             }
             else
             {
                 if (WeaponComponent is RepairTool repairTool)
                 {
-                    if (Vector2.DistanceSquared(character.Position, Enemy.Position) > repairTool.Range * repairTool.Range) { return; }
+                    if (sqrDist > repairTool.Range * repairTool.Range) { return; }
                 }
                 if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - Weapon.Position) < MathHelper.PiOver4)
                 {
@@ -645,7 +874,6 @@ namespace Barotrauma
                     {
                         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);
                     if (pickedBody != null)
@@ -679,6 +907,15 @@ namespace Barotrauma
             }
         }
 
+        protected override void OnCompleted()
+        {
+            base.OnCompleted();
+            if (Weapon != null)
+            {
+                Unequip();
+            }
+        }
+
         //private float CalculateEnemyStrength()
         //{
         //    float enemyStrength = 0;

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

@@ -16,6 +16,9 @@ namespace Barotrauma
         public string[] ignoredContainerIdentifiers;
         public bool checkInventory = true;
 
+        //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs)
+        private bool spawnItemIfNotFound = false;
+
         //can either be a tag or an identifier
         public readonly string[] itemIdentifiers;
         public readonly ItemContainer container;
@@ -38,13 +41,14 @@ namespace Barotrauma
             this.item = item;
         }
 
-        public AIObjectiveContainItem(Character character, string itemIdentifier, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1)
-            : this(character, new string[] { itemIdentifier }, container, objectiveManager, priorityModifier) { }
+        public AIObjectiveContainItem(Character character, string itemIdentifier, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1, bool spawnItemIfNotFound = false)
+            : this(character, new string[] { itemIdentifier }, container, objectiveManager, priorityModifier, spawnItemIfNotFound) { }
 
-        public AIObjectiveContainItem(Character character, string[] itemIdentifiers, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1) 
+        public AIObjectiveContainItem(Character character, string[] itemIdentifiers, ItemContainer container, AIObjectiveManager objectiveManager, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
             : base(character, objectiveManager, priorityModifier)
         {
             this.itemIdentifiers = itemIdentifiers;
+            this.spawnItemIfNotFound = spawnItemIfNotFound;
             for (int i = 0; i < itemIdentifiers.Length; i++)
             {
                 itemIdentifiers[i] = itemIdentifiers[i].ToLowerInvariant();
@@ -147,7 +151,7 @@ namespace Barotrauma
             {
                 // No matching items in the inventory, try to get an item
                 TryAddSubObjective(ref getItemObjective, () =>
-                    new AIObjectiveGetItem(character, itemIdentifiers, objectiveManager, equip: Equip, checkInventory: checkInventory)
+                    new AIObjectiveGetItem(character, itemIdentifiers, objectiveManager, equip: Equip, checkInventory: checkInventory, spawnItemIfNotFound: spawnItemIfNotFound)
                     {
                         GetItemPriority = GetItemPriority,
                         ignoredContainerIdentifiers = ignoredContainerIdentifiers,

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

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Barotrauma
 {
@@ -8,6 +9,7 @@ namespace Barotrauma
         protected override float IgnoreListClearInterval => 30;
         public override bool IgnoreUnsafeHulls => true;
 
+
         public AIObjectiveFightIntruders(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1) 
             : base(character, objectiveManager, priorityModifier) { }
 
@@ -21,8 +23,25 @@ namespace Barotrauma
             return 100;
         }
 
-        protected override AIObjective ObjectiveConstructor(Character target) 
-            => new AIObjectiveCombat(character, target, AIObjectiveCombat.CombatMode.Offensive, objectiveManager, PriorityModifier);
+        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)
+            {
+                var reputation = campaign.Map?.CurrentLocation?.Reputation;
+                if (reputation != null && reputation.NormalizedValue < Reputation.HostileThreshold)
+                {
+                    combatObjective.holdFireCondition = () =>
+                    {
+                        //hold fire while the enemy is in the airlock (except if they've attacked us)
+                        if (HumanAIController.GetDamageDoneByAttacker(target) > 0.0f) { return false; }
+                        return target.CurrentHull == null || target.CurrentHull.OutpostModuleTags.Any(t => t.Equals("airlock", System.StringComparison.OrdinalIgnoreCase));
+                    };
+                    character.Speak(TextManager.Get("dialogenteroutpostwarning"), null, Rand.Range(0.5f, 1.0f), "leaveoutpostwarning", 30.0f);
+                }
+            }
+            return combatObjective;
+        }
 
         protected override void OnObjectiveCompleted(AIObjective objective, Character target)
             => HumanAIController.RemoveTargets<AIObjectiveFightIntruders, Character>(character, target);

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

@@ -18,7 +18,7 @@ namespace Barotrauma
 
         public static float lowOxygenThreshold = 10;
 
-        protected override bool Check() => HumanAIController.HasItem(character, gearTag, "oxygensource") || HumanAIController.HasItem(character, fallbackTag, "oxygensource");
+        protected override bool Check() => HumanAIController.HasItem(character, gearTag, out _, "oxygensource", requireEquipped: true) || HumanAIController.HasItem(character, fallbackTag, out _, "oxygensource", requireEquipped: true);
 
         public AIObjectiveFindDivingGear(Character character, bool needDivingSuit, AIObjectiveManager objectiveManager, float priorityModifier = 1) : base(character, objectiveManager, priorityModifier)
         {

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

@@ -1,4 +1,5 @@
-using Microsoft.Xna.Framework;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -140,7 +141,7 @@ namespace Barotrauma
                 {
                     searchHullTimer = SearchHullInterval * Rand.Range(0.9f, 1.1f);
                     previousSafeHull = currentSafeHull;
-                    currentSafeHull = FindBestHull();
+                    currentSafeHull = FindBestHull(allowChangingTheSubmarine: character.TeamID != Character.TeamType.FriendlyNPC);
                     if (currentSafeHull == null)
                     {
                         currentSafeHull = previousSafeHull;
@@ -233,12 +234,30 @@ namespace Barotrauma
 
         public Hull FindBestHull(IEnumerable<Hull> ignoredHulls = null, bool allowChangingTheSubmarine = true)
         {
+            //sort the hulls based on distance and which sub they're in
+            //tends to make the method much faster, because we find a potential hull earlier and can discard further-away hulls more easily
+            //(for instance, an NPC in an outpost might otherwise go through all the hulls in the main sub first and do tons of expensive
+            //path calculations, only to discard all of them when going through the hulls in the outpost)
+            float EstimateHullSuitability(Hull hull)
+            {
+                float dist =
+                    Math.Abs(hull.WorldPosition.X - character.WorldPosition.X) +
+                    Math.Abs(hull.WorldPosition.Y - character.WorldPosition.Y) * 3;
+                float suitability = -dist;
+                if (hull.Submarine != character.Submarine)
+                {
+                    suitability -= 10000.0f;
+                }
+                return suitability;
+            }
+
             Hull bestHull = null;
             float bestValue = 0;
-            foreach (Hull hull in Hull.hullList)
+            foreach (Hull hull in Hull.hullList.OrderByDescending(h => EstimateHullSuitability(h)))
             {
                 if (hull.Submarine == null) { continue; }
                 if (!allowChangingTheSubmarine && hull.Submarine != character.Submarine) { continue; }
+                if (hull.Rect.Height < ConvertUnits.ToDisplayUnits(character.AnimController.ColliderHeightFromFloor) * 2) { continue; }
                 if (ignoredHulls != null && ignoredHulls.Contains(hull)) { continue; }
                 if (HumanAIController.UnreachableHulls.Contains(hull)) { continue; }
                 float hullSafety = 0;
@@ -255,6 +274,11 @@ namespace Barotrauma
                     //skip the hull if the safety is already less than the best hull
                     //(no need to do the expensive pathfinding if we already know we're not going to choose this hull)
                     if (hullSafety < bestValue) { continue; }
+                    //avoid airlock modules if not allowed to change the sub
+                    if (!allowChangingTheSubmarine && hull.OutpostModuleTags.Any(t => t.Equals("airlock", StringComparison.OrdinalIgnoreCase)))
+                    {
+                        continue;
+                    }
                     // Don't allow to go outside if not already outside.
                     var path = PathSteering.PathFinder.FindPath(character.SimPosition, hull.SimPosition, nodeFilter: node => node.Waypoint.CurrentHull != null);
                     if (path.Unreachable)

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

@@ -61,7 +61,7 @@ namespace Barotrauma
             var weldingTool = character.Inventory.FindItemByTag("weldingequipment", true);
             if (weldingTool == null)
             {
-                TryAddSubObjective(ref getWeldingTool, () => new AIObjectiveGetItem(character, "weldingequipment", objectiveManager, true), 
+                TryAddSubObjective(ref getWeldingTool, () => new AIObjectiveGetItem(character, "weldingequipment", objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC), 
                     onAbandon: () => Abandon = true,
                     onCompleted: () => RemoveSubObjective(ref getWeldingTool));
                 return;
@@ -88,7 +88,7 @@ namespace Barotrauma
                 }
                 if (containedItems.None(i => i.HasTag("weldingfuel") && i.Condition > 0.0f))
                 {
-                    TryAddSubObjective(ref refuelObjective, () => new AIObjectiveContainItem(character, "weldingfuel", weldingTool.GetComponent<ItemContainer>(), objectiveManager), 
+                    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;
@@ -130,7 +130,8 @@ namespace Barotrauma
             {
                 TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(Leak, character, objectiveManager)
                 {
-                    AllowGoingOutside = !Leak.IsRoomToRoom && objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>() && HumanAIController.HasDivingSuit(character, conditionPercentage: 50),
+                    // Disabled for now
+                    //AllowGoingOutside = !Leak.IsRoomToRoom && objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>() && HumanAIController.HasDivingSuit(character, conditionPercentage: 50),
                     CloseEnough = reach,
                     DialogueIdentifier = Leak.FlowTargetHull != null ? "dialogcannotreachleak" : null,
                     TargetName = Leak.FlowTargetHull?.DisplayName

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

@@ -22,7 +22,11 @@ namespace Barotrauma
         private string[] itemIdentifiers;
         public IEnumerable<string> Identifiers => itemIdentifiers;
 
+        //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs)
+        private bool spawnItemIfNotFound = false;
+
         private Item targetItem;
+        private Item originalTarget;
         private ISpatialEntity moveToTarget;
         private bool isDoneSeeking;
         public Item TargetItem => targetItem;
@@ -41,19 +45,21 @@ namespace Barotrauma
         {
             currSearchIndex = -1;
             this.equip = equip;
+            originalTarget = targetItem;
             this.targetItem = targetItem;
             moveToTarget = targetItem?.GetRootInventoryOwner();
         }
 
-        public AIObjectiveGetItem(Character character, string itemIdentifier, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1) 
-            : this(character, new string[] { itemIdentifier }, objectiveManager, equip, checkInventory, priorityModifier) { }
+        public AIObjectiveGetItem(Character character, string itemIdentifier, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
+            : this(character, new string[] { itemIdentifier }, objectiveManager, equip, checkInventory, priorityModifier, spawnItemIfNotFound) { }
 
-        public AIObjectiveGetItem(Character character, string[] itemIdentifiers, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1) 
+        public AIObjectiveGetItem(Character character, string[] itemIdentifiers, AIObjectiveManager objectiveManager, bool equip = true, bool checkInventory = true, float priorityModifier = 1, bool spawnItemIfNotFound = false) 
             : base(character, objectiveManager, priorityModifier)
         {
             currSearchIndex = -1;
             this.equip = equip;
             this.itemIdentifiers = itemIdentifiers;
+            this.spawnItemIfNotFound = spawnItemIfNotFound;
             for (int i = 0; i < itemIdentifiers.Length; i++)
             {
                 itemIdentifiers[i] = itemIdentifiers[i].ToLowerInvariant();
@@ -109,6 +115,14 @@ namespace Barotrauma
             {
 #if DEBUG
                 DebugConsole.NewMessage($"{character.Name}: Target null or removed. Aborting.", Color.Red);
+#endif
+                Abandon = true;
+                return;
+            }
+            else if (isDoneSeeking && moveToTarget == null)
+            {
+#if DEBUG
+                DebugConsole.NewMessage($"{character.Name}: Move target null. Aborting.", Color.Red);
 #endif
                 Abandon = true;
                 return;
@@ -118,8 +132,15 @@ namespace Barotrauma
 #if DEBUG
                 DebugConsole.NewMessage($"{character.Name}: Found an item, but it's already equipped by someone else.", Color.Yellow);
 #endif
-                // Try again
-                Reset();
+                if (originalTarget == null)
+                {
+                    // Try again
+                    Reset();
+                }
+                else
+                {
+                    Abandon = true;
+                }
                 return;
             }
             bool canInteract = false;
@@ -155,30 +176,7 @@ namespace Barotrauma
 
                 if (equip)
                 {
-                    int targetSlot = -1;
-                    //check if all the slots required by the item are free
-                    foreach (InvSlotType slots in pickable.AllowedSlots)
-                    {
-                        if (slots.HasFlag(InvSlotType.Any)) { continue; }
-                        for (int i = 0; i < character.Inventory.Items.Length; i++)
-                        {
-                            //slot not needed by the item, continue
-                            if (!slots.HasFlag(character.Inventory.SlotTypes[i])) { continue; }
-                            targetSlot = i;
-                            //slot free, continue
-                            var otherItem = character.Inventory.Items[i];
-                            if (otherItem == null) { continue; }
-                            //try to move the existing item to LimbSlot.Any and continue if successful
-                            if (otherItem.AllowedSlots.Contains(InvSlotType.Any) && 
-                                character.Inventory.TryPutItem(otherItem, character, new List<InvSlotType>() { InvSlotType.Any }))
-                            {
-                                continue;
-                            }
-                            //if everything else fails, simply drop the existing item
-                            otherItem.Drop(character);
-                        }
-                    }
-                    if (character.Inventory.TryPutItem(targetItem, targetSlot, false, false, character))
+                    if (HumanAIController.TryToMoveItem(targetItem, character.Inventory))
                     {
                         targetItem.Equip(character);
                         IsCompleted = true;
@@ -193,7 +191,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    if (character.Inventory.TryPutItem(targetItem, null, new List<InvSlotType>() { InvSlotType.Any }))
+                    if (character.Inventory.TryPutItem(targetItem, character, new List<InvSlotType>() { InvSlotType.Any }))
                     {
                         IsCompleted = true;
                     }
@@ -283,10 +281,34 @@ namespace Barotrauma
                 isDoneSeeking = true;
                 if (targetItem == null)
                 {
+                    if (spawnItemIfNotFound)
+                    {
+                        if (!(MapEntityPrefab.List.FirstOrDefault(me => me is ItemPrefab ip && itemIdentifiers.Any(id => id == ip.Identifier || ip.Tags.Contains(id))) is ItemPrefab prefab))
+                        {
 #if DEBUG
-                    DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s): {string.Join(", ", itemIdentifiers)}", Color.Yellow);
+                            DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s): {string.Join(", ", itemIdentifiers)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
 #endif
-                    Abandon = true;
+                            Abandon = true;
+                        }
+                        else
+                        {
+                            Entity.Spawner.AddToSpawnQueue(prefab, character.Inventory, onSpawned: (Item spawnedItem) => 
+                            {
+                                targetItem = spawnedItem; 
+                                if (character.TeamID == Character.TeamType.FriendlyNPC && (character.Submarine?.Info.IsOutpost ?? false))
+                                {
+                                    spawnedItem.SpawnedInOutpost = true;
+                                }
+                            });
+                        }
+                    }
+                    else
+                    {
+#if DEBUG
+                        DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s): {string.Join(", ", itemIdentifiers)}", Color.Yellow);
+#endif
+                        Abandon = true;
+                    }
                 }
             }
         }
@@ -323,8 +345,8 @@ namespace Barotrauma
         {
             base.Reset();
             RemoveSubObjective(ref goToObjective);
-            targetItem = null;
-            moveToTarget = null;
+            targetItem = originalTarget;
+            moveToTarget = targetItem?.GetRootInventoryOwner();
             isDoneSeeking = false;
             currSearchIndex = 0;
         }

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

@@ -25,10 +25,13 @@ namespace Barotrauma
         public Func<bool> abortCondition;
         public Func<PathNode, bool> endNodeFilter;
 
+        public Func<float> priorityGetter;
+
         public bool followControlledCharacter;
         public bool mimic;
 
         private float _closeEnough = 50;
+        private readonly float minDistance = 25;
         /// <summary>
         /// Display units
         /// </summary>
@@ -37,7 +40,7 @@ namespace Barotrauma
             get { return _closeEnough; }
             set
             {
-                _closeEnough = Math.Max(_closeEnough, value);
+                _closeEnough = Math.Max(minDistance, value);
             }
         }
         public bool IgnoreIfTargetDead { get; set; }
@@ -52,6 +55,8 @@ namespace Barotrauma
 
         public ISpatialEntity Target { get; private set; }
 
+        public float? OverridePriority = null;
+
         public override float GetPriority()
         {
             if (followControlledCharacter && Character.Controlled == null)
@@ -68,7 +73,18 @@ namespace Barotrauma
             }
             else
             {
-                Priority = objectiveManager.CurrentOrder == this ? AIObjectiveManager.OrderPriority : 10;
+                if (priorityGetter != null)
+                {
+                    Priority = priorityGetter();
+                }
+                else if (OverridePriority.HasValue)
+                {
+                    Priority = OverridePriority.Value;
+                }
+                else
+                {
+                    Priority = objectiveManager.CurrentOrder == this ? AIObjectiveManager.OrderPriority : 10;
+                }
             }
             return Priority;
         }
@@ -86,7 +102,8 @@ namespace Barotrauma
             }
             else if (Target is Character)
             {
-                CloseEnough = Math.Max(closeEnough, AIObjectiveGetItem.DefaultReach);
+                //if closeEnough value is given, allow setting CloseEnough as low as 50, otherwise above AIObjectiveGetItem.DefaultReach
+                CloseEnough = Math.Max(closeEnough, MathUtils.NearlyEqual(closeEnough, 0.0f) ? AIObjectiveGetItem.DefaultReach : 50);
             }
             else
             {
@@ -289,7 +306,7 @@ namespace Barotrauma
             return null;
         }
 
-        private bool IsCloseEnough
+        public bool IsCloseEnough
         {
             get
             {

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

@@ -1,4 +1,5 @@
-using FarseerPhysics;
+using Barotrauma.Items.Components;
+using FarseerPhysics;
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
@@ -12,12 +13,48 @@ namespace Barotrauma
         public override bool UnequipItems => true;
         public override bool AllowOutsideSubmarine => true;
 
-        private readonly float newTargetIntervalMin = 10;
-        private readonly float newTargetIntervalMax = 20;
-        private readonly float standStillMin = 2;
-        private readonly float standStillMax = 10;
-        private readonly float walkDurationMin = 5;
-        private readonly float walkDurationMax = 10;
+        private BehaviorType behavior;
+        public BehaviorType Behavior
+        {
+            get { return behavior; }
+            set 
+            { 
+                behavior = value;
+                switch (behavior)
+                {
+                    case BehaviorType.Active:
+                        newTargetIntervalMin = 10;
+                        newTargetIntervalMax = 20;
+                        standStillMin = 2;
+                        standStillMax = 10;
+                        walkDurationMin = 5;
+                        walkDurationMax = 10;
+                        break;
+                    case BehaviorType.Passive:
+                        newTargetIntervalMin = 60;
+                        newTargetIntervalMax = 120;
+                        standStillMin = 30;
+                        standStillMax = 60;
+                        walkDurationMin = 5;
+                        walkDurationMax = 10;
+                        break;
+                }
+            }
+        }
+
+        private float newTargetIntervalMin;
+        private float newTargetIntervalMax;
+        private float standStillMin;
+        private float standStillMax;
+        private float walkDurationMin;
+        private float walkDurationMax;
+
+        public enum BehaviorType
+        {
+            Active,
+            Passive,
+            StayInHull
+        }
 
         private Hull currentTarget;
         private float newTargetTimer;
@@ -27,13 +64,20 @@ namespace Barotrauma
         private float standStillTimer;
         private float walkDuration;
 
+        private Character tooCloseCharacter;
+
+        const float chairCheckInterval = 5.0f;
+        private float chairCheckTimer;
+
         private readonly List<Hull> targetHulls = new List<Hull>(20);
         private readonly List<float> hullWeights = new List<float>(20);
 
         public AIObjectiveIdle(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1) : base(character, objectiveManager, priorityModifier)
         {
+            Behavior = BehaviorType.Passive;
             standStillTimer = Rand.Range(-10.0f, 10.0f);
             walkDuration = Rand.Range(0.0f, 10.0f);
+            chairCheckTimer = Rand.Range(0.0f, chairCheckInterval);
             CalculatePriority();
         }
 
@@ -42,9 +86,12 @@ namespace Barotrauma
 
         public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace); }
 
-        private float randomTimer;
-        private float randomUpdateInterval = 5;
-        public float Random { get; private set; }
+        public readonly HashSet<string> PreferredOutpostModuleTypes = new HashSet<string>();
+
+        private bool IsInWrongSub() => 
+            character.Submarine == null ||
+            currentTarget != null && currentTarget.Submarine != character.Submarine ||
+            character.TeamID == Character.TeamType.FriendlyNPC && character.Submarine.TeamID != character.TeamID;
 
         public void CalculatePriority(float max = 0)
         {
@@ -73,6 +120,31 @@ namespace Barotrauma
             //}
         }
 
+        private float timerMargin;
+
+        private void SetTargetTimerLow()
+        {
+            // Increases the margin each time the method is called -> takes longer between the path finding calls.
+            // The intention behind this is to reduce unnecessary path finding calls in cases where the bot can't find a path.
+            timerMargin += 0.5f;
+            timerMargin = Math.Min(timerMargin, newTargetIntervalMin);
+            newTargetTimer = Math.Min(newTargetTimer, timerMargin);
+        }
+
+        private void SetTargetTimerHigh()
+        {
+            // This method is used to the timer between the current value and the min so that it never reaches 0.
+            // Prevents pathfinder calls.
+            newTargetTimer = Math.Max(newTargetTimer, newTargetIntervalMin);
+            timerMargin = 0;
+        }
+
+        private void SetTargetTimerNormal()
+        {
+            newTargetTimer = currentTarget != null && character.AnimController.InWater ? newTargetIntervalMin : Rand.Range(newTargetIntervalMin, newTargetIntervalMax);
+            timerMargin = 0;
+        }
+
         protected override void Act(float deltaTime)
         {
             if (PathSteering == null) { return; }
@@ -82,97 +154,95 @@ namespace Barotrauma
             {
                 character.DeselectCharacter();
             }
-            if (!character.IsClimbing)
-            {
-                character.SelectedConstruction = null;
-            }
 
-            bool currentTargetIsInvalid = currentTarget == null || IsForbidden(currentTarget) || 
-                (PathSteering.CurrentPath != null && PathSteering.CurrentPath.Nodes.Any(n => HumanAIController.UnsafeHulls.Contains(n.CurrentHull)));
+            if (behavior != BehaviorType.StayInHull)
+            {
+                bool currentTargetIsInvalid = currentTarget == null || IsForbidden(currentTarget) || 
+                    (PathSteering.CurrentPath != null && PathSteering.CurrentPath.Nodes.Any(n => HumanAIController.UnsafeHulls.Contains(n.CurrentHull)));
 
-            if (currentTargetIsInvalid || currentTarget == null && HumanAIController.VisibleHulls.Any(h => IsForbidden(h)))
-            {
-                //don't reset to zero, otherwise the character will keep calling FindTargetHulls 
-                //almost constantly when there's a small number of potential hulls to move to
-                newTargetTimer = Math.Min(newTargetTimer, 0.5f);
-                //standStillTimer = 0.0f;
-            }
-            else if (character.IsClimbing)
-            {
-                if (currentTarget == null)
+                bool IsSteeringFinished() => PathSteering.CurrentPath != null && PathSteering.CurrentPath.Finished;
+
+                if (currentTargetIsInvalid || currentTarget == null || IsSteeringFinished() && (IsForbidden(character.CurrentHull) || IsInWrongSub()))
                 {
-                    newTargetTimer = 0;
+                    //don't reset to zero, otherwise the character will keep calling FindTargetHulls 
+                    //almost constantly when there's a small number of potential hulls to move to
+                    SetTargetTimerLow();
                 }
-                else if (Math.Abs(character.AnimController.TargetMovement.Y) > 0.9f)
+                else if (character.IsClimbing)
                 {
-                    // Don't allow new targets when climbing straight up or down
-                    newTargetTimer = Math.Max(newTargetIntervalMin, newTargetTimer);
-                }
-            }
-            else if (character.AnimController.InWater)
-            {
-                if (currentTarget == null)
-                {
-                    newTargetTimer = Math.Min(newTargetTimer, 0.5f);
-                }
-            }
-            if (newTargetTimer <= 0.0f)
-            {
-                if (!searchingNewHull)
-                {
-                    //find all available hulls first
-                    FindTargetHulls();
-                    searchingNewHull = true;
-                    return;
-                }
-                else if (targetHulls.Count > 0)
-                {
-                    //choose a random available hull
-                    currentTarget = ToolBox.SelectWeightedRandom(targetHulls, hullWeights, Rand.RandSync.Unsynced);
-                    bool isCurrentHullAllowed = !IsForbidden(character.CurrentHull);
-                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: $"AIObjectiveIdle {character.DisplayName}", nodeFilter: node =>
+                    if (currentTarget == null)
                     {
-                        if (node.Waypoint.CurrentHull == null) { return false; }
-                        // Check that there is no unsafe or forbidden hulls on the way to the target
-                        if (node.Waypoint.CurrentHull != character.CurrentHull && HumanAIController.UnsafeHulls.Contains(node.Waypoint.CurrentHull)) { return false; }
-                        if (isCurrentHullAllowed && IsForbidden(node.Waypoint.CurrentHull)) { return false; }
-                        return true;
-                    });
-                    if (path.Unreachable)
+                        SetTargetTimerLow();
+                    }
+                    else if (Math.Abs(character.AnimController.TargetMovement.Y) > 0.9f)
                     {
-                        //can't go to this room, remove it from the list and try another room next frame
-                        int index = targetHulls.IndexOf(currentTarget);
-                        targetHulls.RemoveAt(index);
-                        hullWeights.RemoveAt(index);
-                        PathSteering.Reset();
-                        currentTarget = null;
+                        // Don't allow new targets when climbing straight up or down
+                        SetTargetTimerHigh();
+                    }
+                }
+                else if (character.AnimController.InWater)
+                {
+                    if (currentTarget == null)
+                    {
+                        SetTargetTimerLow();
+                    }
+                }
+                if (newTargetTimer <= 0.0f)
+                {
+                    if (!searchingNewHull)
+                    {
+                        //find all available hulls first
+                        FindTargetHulls();
+                        searchingNewHull = true;
                         return;
                     }
-                    searchingNewHull = false;
-                }
-                else
-                {
-                    // Couldn't find a target for some reason -> reset
-                    newTargetTimer = Math.Max(newTargetIntervalMin, newTargetTimer);
-                    searchingNewHull = false;
-                }
+                    else if (targetHulls.Count > 0)
+                    {
+                        //choose a random available hull
+                        currentTarget = ToolBox.SelectWeightedRandom(targetHulls, hullWeights, Rand.RandSync.Unsynced);
+                        bool isCurrentHullAllowed = !IsInWrongSub() && !IsForbidden(character.CurrentHull);
+                        var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: $"AIObjectiveIdle {character.DisplayName}", nodeFilter: node =>
+                        {
+                            if (node.Waypoint.CurrentHull == null) { return false; }
+                            // Check that there is no unsafe or forbidden hulls on the way to the target
+                            if (node.Waypoint.CurrentHull != character.CurrentHull && HumanAIController.UnsafeHulls.Contains(node.Waypoint.CurrentHull)) { return false; }
+                            if (isCurrentHullAllowed && IsForbidden(node.Waypoint.CurrentHull)) { return false; }
+                            return true;
+                        });
+                        if (path.Unreachable)
+                        {
+                            //can't go to this room, remove it from the list and try another room next frame
+                            int index = targetHulls.IndexOf(currentTarget);
+                            targetHulls.RemoveAt(index);
+                            hullWeights.RemoveAt(index);
+                            PathSteering.Reset();
+                            currentTarget = null;
+                            return;
+                        }
+                        searchingNewHull = false;
+                    }
+                    else
+                    {
+                        // Couldn't find a target for some reason -> reset
+                        SetTargetTimerHigh();
+                        searchingNewHull = false;
+                    }
 
-                if (currentTarget != null)
-                {
-                    character.AIController.SelectTarget(currentTarget.AiTarget);
-                    string errorMsg = null;
-#if DEBUG
-                    bool isRoomNameFound = currentTarget.DisplayName != null;
-                    errorMsg = "(Character " + character.Name + " idling, target " + (isRoomNameFound ? currentTarget.DisplayName : currentTarget.ToString()) + ")";
-#endif
-                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: errorMsg, nodeFilter: node => node.Waypoint.CurrentHull != null);
-                    PathSteering.SetPath(path);
-                }
-
-                newTargetTimer = currentTarget != null && character.AnimController.InWater ? newTargetIntervalMin : Rand.Range(newTargetIntervalMin, newTargetIntervalMax);
+                    if (currentTarget != null)
+                    {
+                        character.AIController.SelectTarget(currentTarget.AiTarget);
+                        string errorMsg = null;
+    #if DEBUG
+                        bool isRoomNameFound = currentTarget.DisplayName != null;
+                        errorMsg = "(Character " + character.Name + " idling, target " + (isRoomNameFound ? currentTarget.DisplayName : currentTarget.ToString()) + ")";
+    #endif
+                        var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: errorMsg, nodeFilter: node => node.Waypoint.CurrentHull != null);
+                        PathSteering.SetPath(path);
+                    }
+                    SetTargetTimerNormal();
+                }            
+                newTargetTimer -= deltaTime;
             }
-            
-            newTargetTimer -= deltaTime;
 
             //wander randomly 
             // - if reached the end of the path 
@@ -180,12 +250,13 @@ namespace Barotrauma
             // - if the path requires going outside
             if (!character.IsClimbing)
             {
-                if (SteeringManager != PathSteering || (PathSteering.CurrentPath != null &&
+                if (behavior == BehaviorType.StayInHull || SteeringManager != PathSteering || (PathSteering.CurrentPath != null &&
                     (PathSteering.CurrentPath.Finished || PathSteering.CurrentPath.Unreachable || PathSteering.CurrentPath.HasOutdoorsNodes)))
                 {
                     Wander(deltaTime);
                     return;
                 }
+                character.SelectedConstruction = null;
             }
 
             if (currentTarget != null)
@@ -214,7 +285,58 @@ namespace Barotrauma
                 if (standStillTimer > 0.0f)
                 {
                     walkDuration = Rand.Range(walkDurationMin, walkDurationMax);
-                    PathSteering.Reset();
+
+                    if (character.CurrentHull != null && character.CurrentHull.Rect.Width > 150 && tooCloseCharacter == null)
+                    {
+                        foreach (Character c in Character.CharacterList)
+                        {
+                            if (c == character || !c.IsBot || c.CurrentHull != character.CurrentHull || !(c.AIController is HumanAIController humanAI)) { continue; }
+                            if (Vector2.DistanceSquared(c.WorldPosition, character.WorldPosition) > 60.0f * 60.0f) { continue; }
+                            if ((humanAI.ObjectiveManager.CurrentObjective is AIObjectiveIdle idleObjective && idleObjective.standStillTimer > 0.0f) ||
+                                (humanAI.ObjectiveManager.CurrentObjective is AIObjectiveGoTo gotoObjective && gotoObjective.IsCloseEnough))
+                            {
+                                //if there are characters too close on both sides, don't try to steer away from them
+                                //because it'll cause the character to spaz out trying to avoid both
+                                if (tooCloseCharacter != null && 
+                                    Math.Sign(tooCloseCharacter.WorldPosition.X - character.WorldPosition.X) != Math.Sign(c.WorldPosition.X - character.WorldPosition.X))
+                                {
+                                    tooCloseCharacter = null;
+                                    break;
+                                }
+                                tooCloseCharacter = c; 
+                            }
+                            HumanAIController.FaceTarget(c);                            
+                        }
+                    }
+
+                    if (tooCloseCharacter != null && !tooCloseCharacter.Removed && Vector2.DistanceSquared(tooCloseCharacter.WorldPosition, character.WorldPosition) < 50.0f * 50.0f)
+                    {
+                        Vector2 diff = character.WorldPosition - tooCloseCharacter.WorldPosition;
+                        if (diff.LengthSquared() < 0.0001f) { diff = Rand.Vector(1.0f); }
+                        if (diff.X > 0 && character.WorldPosition.X > character.CurrentHull.WorldRect.Right - 50) { diff.X = -diff.X; }
+                        if (diff.X < 0 && character.WorldPosition.X < character.CurrentHull.WorldRect.X + 50) { diff.X = -diff.X; }
+                        PathSteering.SteeringManual(deltaTime, Vector2.Normalize(diff));
+                        return;
+                    }
+                    else
+                    {
+                        PathSteering.Reset();
+                        tooCloseCharacter = null;
+                    }
+
+                    chairCheckTimer -= deltaTime;
+                    if (chairCheckTimer <= 0.0f && character.SelectedConstruction == null)
+                    {
+                        foreach (Item item in Item.ItemList)
+                        {
+                            if (item.CurrentHull != character.CurrentHull || !item.HasTag("chair")) { continue; }
+                            var controller = item.GetComponent<Controller>();
+                            if (controller == null || controller.User != null) { continue; }
+                            item.TryInteract(character, forceSelectKey: true);
+                        }
+                        chairCheckTimer = chairCheckInterval;
+                    }
+
                     return;
                 }
                 if (standStillTimer < -walkDuration)
@@ -222,6 +344,7 @@ namespace Barotrauma
                     standStillTimer = Rand.Range(standStillMin, standStillMax);
                 }
             }
+
             PathSteering.Wander(deltaTime);
         }
 
@@ -234,12 +357,27 @@ namespace Barotrauma
                 if (HumanAIController.UnsafeHulls.Contains(hull)) { continue; }
                 if (hull.Submarine == null) { continue; }
                 if (character.Submarine == null) { break; }
-                if (hull.Submarine.TeamID != character.Submarine.TeamID) { continue; }
-                if (hull.Submarine.Info.Type != character.Submarine.Info.Type) { continue; }
-                // If the character is inside, only take connected subs into account.
-                if (!character.Submarine.IsEntityFoundOnThisSub(hull, true)) { continue; }
+                if (character.TeamID == Character.TeamType.FriendlyNPC)
+                {
+                    if (hull.Submarine.TeamID != character.TeamID)
+                    {
+                        // Don't allow npcs to idle in a sub that's not in their team (like the player sub)
+                        continue;
+                    }
+                }
+                else
+                {
+                    if (hull.Submarine.TeamID != character.Submarine.TeamID)
+                    {
+                        // Don't allow to idle in the subs that are not in the same team as the current sub
+                        // -> the crew ai bots can't change the sub from outpost to main sub or vice versa on their own
+                        continue;
+                    }
+                }
                 if (IsForbidden(hull)) { continue; }
-                // Ignore hulls that are too low to stand inside
+                // Check that the hull is linked
+                if (!character.Submarine.GetConnectedSubs().Contains(hull.Submarine)) { continue; }
+                // Ignore hulls that are too low to stand inside.
                 if (character.AnimController is HumanoidAnimController animController)
                 {
                     if (hull.CeilingHeight < ConvertUnits.ToDisplayUnits(animController.HeadPosition.Value))
@@ -260,6 +398,17 @@ namespace Barotrauma
                     hullWeights.Add(weight);
                 }
             }
+
+            if (PreferredOutpostModuleTypes.Any() && character.CurrentHull != null)
+            {
+                for (int i = 0; i < targetHulls.Count; i++)
+                {
+                    if (targetHulls[i].OutpostModuleTags.Any(t => PreferredOutpostModuleTypes.Contains(t)))
+                    {
+                        hullWeights[i] *= Rand.Range(10.0f, 100.0f);
+                    }
+                }
+            }
         }
 
         public static bool IsForbidden(Hull hull)

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

@@ -23,6 +23,8 @@ namespace Barotrauma
 
         private readonly Character character;
 
+        public HumanAIController HumanAIController => character.AIController as HumanAIController;
+
 
         private float _waitTimer;
         /// <summary>
@@ -123,7 +125,7 @@ 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, false)?.GetRandom() : null;
+                var item = orderPrefab.MustSetTarget ? orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID)?.GetRandom() : null;
                 var order = new Order(orderPrefab, item ?? character.CurrentHull as Entity,
                     item?.Components.FirstOrDefault(ic => ic.GetType() == orderPrefab.ItemComponentType), orderGiver: character);
                 if (order == null) { continue; }
@@ -298,7 +300,7 @@ namespace Barotrauma
                     if (orderGiver == null) { return null; }
                     newObjective = new AIObjectiveGoTo(orderGiver, character, this, repeat: true, priorityModifier: priorityModifier)
                     {
-                        CloseEnough = 100,
+                        CloseEnough = Rand.Range(90, 100) + Rand.Range(50, 70) * Math.Min(HumanAIController.CountCrew(c => c.ObjectiveManager.CurrentOrder is AIObjectiveGoTo gotoOrder && gotoOrder.Target == orderGiver, onlyBots: true), 4),
                         AllowGoingOutside = true,
                         IgnoreIfTargetDead = true,
                         followControlledCharacter = orderGiver == character,

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

@@ -81,11 +81,11 @@ namespace Barotrauma
                             break;
                     }
                 }
-                if (targetItem.CurrentHull == null || targetItem.CurrentHull.FireSources.Any() || HumanAIController.IsItemOperatedByAnother(target, out _))
-                {
-                    Priority = 0;
-                }
-                else if (Character.CharacterList.Any(c => c.CurrentHull == targetItem.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
+                if (targetItem.CurrentHull == null ||
+                    targetItem.Submarine != character.Submarine && objectiveManager.CurrentOrder != this ||
+                    targetItem.CurrentHull.FireSources.Any() ||
+                    HumanAIController.IsItemOperatedByAnother(target, out _) ||
+                    Character.CharacterList.Any(c => c.CurrentHull == targetItem.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
                 {
                     Priority = 0;
                 }
@@ -111,10 +111,10 @@ namespace Barotrauma
             var target = GetTarget();
             if (target == null)
             {
+                Abandon = true;
 #if DEBUG
                 throw new Exception("target null");
 #endif
-                Abandon = true;
             }
             else if (target.Item.NonInteractable)
             {

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

@@ -51,7 +51,7 @@ namespace Barotrauma
                     float dist = Math.Abs(character.WorldPosition.X - Item.WorldPosition.X) + yDist;
                     distanceFactor = MathHelper.Lerp(1, 0.25f, MathUtils.InverseLerp(0, 5000, dist));
                 }
-                float severity = isPriority ? 1 : AIObjectiveRepairItems.GetTargetPriority(Item, character);
+                float severity = isPriority ? 1 : AIObjectiveRepairItems.GetTargetPriority(Item, character, requiredSuccessFactor: objectiveManager.CurrentOrder != this ? AIObjectiveRepairItems.RequiredSuccessFactor : 0);
                 float isSelected = IsRepairing ? 50 : 0;
                 float devotion = (CumulatedDevotion + isSelected) / 100;
                 float max = MathHelper.Min(AIObjectiveManager.OrderPriority - 1, 90);
@@ -148,7 +148,8 @@ namespace Barotrauma
                     {
                         if (character.SelectedConstruction != Item)
                         {
-                            if (!Item.TryInteract(character, true, true))
+                            if (!Item.TryInteract(character, ignoreRequiredItems: true, forceSelectKey: true) &&
+                                !Item.TryInteract(character, ignoreRequiredItems: true, forceActionKey: true))
                             {
                                 Abandon = true;
                             }

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

@@ -25,6 +25,8 @@ namespace Barotrauma
 
         public override bool AllowMultipleInstances => true;
 
+        public readonly static float RequiredSuccessFactor = 0.4f;
+
         public override bool IsDuplicate<T>(T otherObjective) => 
             (otherObjective as AIObjective) is AIObjectiveRepairItems repairObjective && repairObjective.RequireAdequateSkills == RequireAdequateSkills;
 
@@ -110,7 +112,7 @@ namespace Barotrauma
                 }
                 if (RequireAdequateSkills)
                 {
-                    return Targets.Sum(t => GetTargetPriority(t, character)) * ratio;
+                    return Targets.Sum(t => GetTargetPriority(t, character, RequiredSuccessFactor)) * ratio;
                 }
                 else
                 {
@@ -119,10 +121,14 @@ namespace Barotrauma
             }
         }
 
-        public static float GetTargetPriority(Item item, Character character)
+        public static float GetTargetPriority(Item item, Character character, float requiredSuccessFactor = 0)
         {
             float damagePriority = MathHelper.Lerp(1, 0, item.Condition / item.MaxCondition);
             float successFactor = MathHelper.Lerp(0, 1, item.Repairables.Average(r => r.DegreeOfSuccess(character)));
+            if (successFactor < requiredSuccessFactor)
+            {
+                return 0;
+            }
             return MathHelper.Lerp(0, 100, MathHelper.Clamp(damagePriority * successFactor, 0, 1));
         }
 

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

@@ -12,6 +12,8 @@ namespace Barotrauma
         public override bool ForceRun => true;
         public override bool KeepDivingGearOn => true;
 
+        public override bool AllowOutsideSubmarine => true;
+
         const float TreatmentDelay = 0.5f;
 
         const float CloseEnoughToTreat = 100.0f;
@@ -216,50 +218,53 @@ namespace Barotrauma
                     }
                 }
             }
-
-            float cprSuitability = targetCharacter.Oxygen < 0.0f ? -targetCharacter.Oxygen * 100.0f : 0.0f;
-            //didn't have any suitable treatments available, try to find some medical items
-            if (currentTreatmentSuitabilities.Any(s => s.Value > cprSuitability))
+            // Find treatments outside of own inventory only if inside the own sub.
+            if (character.Submarine != null && character.Submarine.TeamID == character.TeamID)
             {
-                itemNameList.Clear();
-                suitableItemIdentifiers.Clear();
-                foreach (KeyValuePair<string, float> treatmentSuitability in currentTreatmentSuitabilities)
+                float cprSuitability = targetCharacter.Oxygen < 0.0f ? -targetCharacter.Oxygen * 100.0f : 0.0f;
+                //didn't have any suitable treatments available, try to find some medical items
+                if (currentTreatmentSuitabilities.Any(s => s.Value > cprSuitability))
                 {
-                    if (treatmentSuitability.Value <= cprSuitability) { continue; }
-                    if (MapEntityPrefab.Find(null, treatmentSuitability.Key, showErrorMessages: false) is ItemPrefab itemPrefab)
+                    itemNameList.Clear();
+                    suitableItemIdentifiers.Clear();
+                    foreach (KeyValuePair<string, float> treatmentSuitability in currentTreatmentSuitabilities)
                     {
-                        if (!Item.ItemList.Any(it => it.prefab.Identifier == treatmentSuitability.Key)) { continue; }
-                        suitableItemIdentifiers.Add(treatmentSuitability.Key);
-                        //only list the first 4 items
-                        if (itemNameList.Count < 4)
+                        if (treatmentSuitability.Value <= cprSuitability) { continue; }
+                        if (MapEntityPrefab.Find(null, treatmentSuitability.Key, showErrorMessages: false) is ItemPrefab itemPrefab)
                         {
-                            itemNameList.Add(itemPrefab.Name);
+                            if (!Item.ItemList.Any(it => it.prefab.Identifier == treatmentSuitability.Key)) { continue; }
+                            suitableItemIdentifiers.Add(treatmentSuitability.Key);
+                            //only list the first 4 items
+                            if (itemNameList.Count < 4)
+                            {
+                                itemNameList.Add(itemPrefab.Name);
+                            }
                         }
                     }
-                }
-                if (itemNameList.Count > 0)
-                {
-                    string itemListStr = "";
-                    if (itemNameList.Count == 1)
+                    if (itemNameList.Count > 0)
                     {
-                        itemListStr = itemNameList[0];
+                        string itemListStr = "";
+                        if (itemNameList.Count == 1)
+                        {
+                            itemListStr = itemNameList[0];
+                        }
+                        else
+                        {
+                            itemListStr = string.Join(" or ", string.Join(", ", itemNameList.Take(itemNameList.Count - 1)), itemNameList.Last());
+                        }
+                        if (targetCharacter != character)
+                        {
+                            character.Speak(TextManager.GetWithVariables("DialogListRequiredTreatments", new string[2] { "[targetname]", "[treatmentlist]" },
+                                new string[2] { targetCharacter.Name, itemListStr }, new bool[2] { false, true }),
+                                null, 2.0f, "listrequiredtreatments" + targetCharacter.Name, 60.0f);
+                        }
+                        character.DeselectCharacter();
+                        RemoveSubObjective(ref getItemObjective);
+                        TryAddSubObjective(ref getItemObjective,
+                            constructor: () => new AIObjectiveGetItem(character, suitableItemIdentifiers.ToArray(), objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC),
+                            onCompleted: () => RemoveSubObjective(ref getItemObjective),
+                            onAbandon: () => RemoveSubObjective(ref getItemObjective));
                     }
-                    else
-                    {
-                        itemListStr = string.Join(" or ", string.Join(", ", itemNameList.Take(itemNameList.Count - 1)), itemNameList.Last());
-                    }
-                    if (targetCharacter != character)
-                    {
-                        character.Speak(TextManager.GetWithVariables("DialogListRequiredTreatments", new string[2] { "[targetname]", "[treatmentlist]" },
-                            new string[2] { targetCharacter.Name, itemListStr }, new bool[2] { false, true }),
-                            null, 2.0f, "listrequiredtreatments" + targetCharacter.Name, 60.0f);
-                    }
-                    character.DeselectCharacter();
-                    RemoveSubObjective(ref getItemObjective);
-                    TryAddSubObjective(ref getItemObjective, 
-                        constructor: () => new AIObjectiveGetItem(character, suitableItemIdentifiers.ToArray(), objectiveManager, equip: true),
-                        onCompleted: () => RemoveSubObjective(ref getItemObjective),
-                        onAbandon: () => RemoveSubObjective(ref getItemObjective));
                 }
             }
             if (character != targetCharacter)

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

@@ -9,9 +9,10 @@ namespace Barotrauma
         public override string DebugTag => "rescue all";
         public override bool ForceRun => true;
         public override bool InverseTargetEvaluation => true;
+        public override bool AllowOutsideSubmarine => true;
 
-        private const float vitalityThreshold = 80;
-        private const float vitalityThresholdForOrders = 100;
+        private const float vitalityThreshold = 75;
+        private const float vitalityThresholdForOrders = 85;
         public static float GetVitalityThreshold(AIObjectiveManager manager, Character character, Character target)
         {
             if (manager == null)
@@ -71,7 +72,8 @@ namespace Barotrauma
         public static bool IsValidTarget(Character target, Character character)
         {
             if (target == null || target.IsDead || target.Removed) { return false; }
-            if (!HumanAIController.IsFriendly(character, target)) { return false; }
+            if (target.TurnedHostileByEvent) { return false; }
+            if (!HumanAIController.IsFriendly(character, target, onlySameTeam: true)) { return false; }
             if (character.AIController is HumanAIController humanAI)
             {
                 if (GetVitalityFactor(target) >= GetVitalityThreshold(humanAI.ObjectiveManager, character, target)) { return false; }
@@ -94,13 +96,8 @@ namespace Barotrauma
                 if (GetVitalityFactor(target) >= vitalityThreshold) { return false; }
             }
             if (target.Submarine == null || character.Submarine == null) { return false; }
-            if (target.Submarine.TeamID != character.Submarine.TeamID) { return false; }
-            if (target.CurrentHull == null) { return false; }
-            if (character.Submarine != null)
-            {
-                if (target.Submarine.Info.Type != character.Submarine.Info.Type) { return false; }
-                if (character.Submarine != null && !character.Submarine.IsEntityFoundOnThisSub(target.CurrentHull, true)) { return false; }
-            }
+            // Don't allow going into another sub, unless it's connected and of the same team and type.
+            if (!character.Submarine.IsEntityFoundOnThisSub(target.CurrentHull, includingConnectedSubs: true)) { return false; }
             if (target != character &&!target.IsPlayer && HumanAIController.IsActive(target) && target.AIController is HumanAIController targetAI)
             {
                 // Ignore all concious targets that are currently fighting, fleeing or treating characters