Release v0.15.12.0

2021-10-27 18:50:57 +03:00
parent bf95e82d80
commit 234fb6bc06
450 changed files with 26042 additions and 10457 deletions
@@ -94,8 +94,9 @@ namespace Barotrauma
                if (_abandon)
                {
 #if DEBUG
-                    if (HumanAIController.debugai && objectiveManager.IsOrder(this) && !objectiveManager.IsCurrentOrder<AIObjectiveGoTo>())
+                    if (HumanAIController.debugai && objectiveManager.IsOrder(this) && !objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() && !objectiveManager.IsCurrentOrder<AIObjectiveReturn>())
                    {
+                        // TODO: dismiss
                        throw new Exception("Order abandoned!");
                    }
 #endif
@@ -83,12 +83,13 @@ namespace Barotrauma
                if (suitableContainer != null)
                {
                    bool equip = item.GetComponent<Holdable>() != null ||
-                            item.AllowedSlots.None(s =>
-                            s == InvSlotType.Card ||
-                            s == InvSlotType.Head ||
-                            s == InvSlotType.Headset ||
-                            s == InvSlotType.InnerClothes ||
-                            s == InvSlotType.OuterClothes);
+                        item.AllowedSlots.Any(s => s != InvSlotType.Any) &&
+                        item.AllowedSlots.None(s =>
+                        s == InvSlotType.Card ||
+                        s == InvSlotType.Head ||
+                        s == InvSlotType.Headset ||
+                        s == InvSlotType.InnerClothes ||
+                        s == InvSlotType.OuterClothes);

                    TryAddSubObjective(ref decontainObjective, () => new AIObjectiveDecontainItem(character, item, objectiveManager, targetContainer: suitableContainer.GetComponent<ItemContainer>())
                    {
@@ -101,17 +101,17 @@ namespace Barotrauma

        public enum CombatMode
        {
-            Defensive,
-            Offensive,
-            Arrest,
-            Retreat,
-            None
+            Defensive,  // Use weapons against the enemy, but try to retreat to a safe place
+            Offensive,  // Engage the enemy and keep attacking it
+            Arrest,     // Try to arrest the enemy without using lethal weapons (stunning + handcuffs)
+            Retreat,    // Run to a safe place without attacking the target
+            None        // Don't use
        }

        public CombatMode Mode { get; private set; }

        private bool IsOffensiveOrArrest => initialMode == CombatMode.Offensive || initialMode == CombatMode.Arrest;
-        private bool TargetEliminated => IsEnemyDisabled || Enemy.IsUnconscious;
+        private bool TargetEliminated => IsEnemyDisabled || (Enemy.IsUnconscious && Enemy.Params.Health.ConstantHealthRegeneration <= 0.0f);
        private bool IsEnemyDisabled => Enemy == null || Enemy.Removed || Enemy.IsDead;

        private float AimSpeed => HumanAIController.AimSpeed;
@@ -252,9 +252,40 @@ namespace Barotrauma
            {
                case CombatMode.Offensive:
                case CombatMode.Arrest:
-                    Engage();
+                    Engage(deltaTime);
                    break;
                case CombatMode.Defensive:
+                    if (character.IsOnPlayerTeam && !Enemy.IsPlayer && objectiveManager.IsCurrentOrder<AIObjectiveGoTo>())
+                    {
+                        if ((character.CurrentHull == null || character.CurrentHull == Enemy.CurrentHull) && sqrDistance < 200 * 200)
+                        {
+                            Engage(deltaTime);
+                        }
+                        else
+                        {
+                            // Keep following the goto target
+                            var gotoObjective = objectiveManager.GetOrder<AIObjectiveGoTo>();
+                            if (gotoObjective != null)
+                            {
+                                gotoObjective.ForceAct(deltaTime);
+                                if (!character.AnimController.InWater)
+                                {
+                                    HumanAIController.FaceTarget(Enemy);
+                                    ForceWalk = true;
+                                    HumanAIController.AutoFaceMovement = false;
+                                }
+                            }
+                            else
+                            {
+                                SteeringManager.Reset();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Retreat(deltaTime);
+                    }
+                    break;
                case CombatMode.Retreat:
                    Retreat(deltaTime);
                    break;
@@ -588,8 +619,9 @@ namespace Barotrauma
                // assume that it's required for the stun effect
                // as we can't check the status effect conditions here.
                var mobileBatteryTag = "mobilebattery";
-                var containers = weapon.Item.Components.Where(ic => ic is ItemContainer container &&
-                    container.ContainableItems.Any(containable => containable.Identifiers.Any(id => id.Equals(mobileBatteryTag))));
+                var containers = weapon.Item.Components.Where(ic => 
+                    ic is ItemContainer container &&
+                    container.ContainableItemIdentifiers.Contains(mobileBatteryTag));
                // If there's no such container, assume that the melee weapon can stun without a battery.
                return containers.None() || containers.Any(container =>
                    (container as ItemContainer)?.Inventory.AllItems.Any(i => i != null && i.HasTag(mobileBatteryTag) && i.Condition > 0.0f) ?? false);
@@ -670,6 +702,14 @@ namespace Barotrauma
            {
                RemoveSubObjective(ref retreatObjective);
            }
+            if (character.Submarine == null && sqrDistance < MathUtils.Pow2(maxDistance))
+            {
+                // Swim away
+                SteeringManager.Reset();
+                SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(character.WorldPosition - Enemy.WorldPosition));
+                SteeringManager.SteeringAvoid(deltaTime, 5, weight: 2);
+                return;
+            }
            if (retreatTarget == null || (retreatObjective != null && !retreatObjective.CanBeCompleted))
            {
                if (findHullTimer > 0)
@@ -684,7 +724,10 @@ namespace Barotrauma
            }
            if (retreatTarget != null && character.CurrentHull != retreatTarget)
            {
-                TryAddSubObjective(ref retreatObjective, () => new AIObjectiveGoTo(retreatTarget, character, objectiveManager, false, true),
+                TryAddSubObjective(ref retreatObjective, () => new AIObjectiveGoTo(retreatTarget, character, objectiveManager, false, true)
+                {
+                    UsePathingOutside = false
+                },
                    onAbandon: () =>
                    {
                        if (Enemy != null && HumanAIController.VisibleHulls.Contains(Enemy.CurrentHull))
@@ -703,7 +746,7 @@ namespace Barotrauma
            }
        }

-        private void Engage()
+        private void Engage(float deltaTime)
        {
            if (WeaponComponent == null)
            {
@@ -721,6 +764,21 @@ namespace Barotrauma
            RemoveSubObjective(ref retreatObjective);
            RemoveSubObjective(ref seekAmmunitionObjective);
            RemoveSubObjective(ref seekWeaponObjective);
+            if (character.Submarine == null && WeaponComponent is MeleeWeapon meleeWeapon)
+            {
+                if (sqrDistance > MathUtils.Pow2(meleeWeapon.Range))
+                {
+                    // Swim towards the target
+                    SteeringManager.Reset();
+                    SteeringManager.SteeringSeek(character.GetRelativeSimPosition(Enemy), weight: 10);
+                    SteeringManager.SteeringAvoid(deltaTime, 5, weight: 15);
+                }
+                else
+                {
+                    SteeringManager.Reset();
+                }
+                return;
+            }
            if (followTargetObjective != null && followTargetObjective.Target != Enemy)
            {
                RemoveFollowTarget();
@@ -728,6 +786,7 @@ namespace Barotrauma
            TryAddSubObjective(ref followTargetObjective,
                constructor: () => new AIObjectiveGoTo(Enemy, character, objectiveManager, repeat: true, getDivingGearIfNeeded: true, closeEnough: 50)
                {
+                    UsePathingOutside = false,
                    IgnoreIfTargetDead = true,
                    DialogueIdentifier = "dialogcannotreachtarget",
                    TargetName = Enemy.DisplayName,
@@ -958,14 +1017,15 @@ namespace Barotrauma
            }
            if (reloadTimer > 0) { return; }
            if (holdFireCondition != null && holdFireCondition()) { return; }
-            float sqrDist = Vector2.DistanceSquared(character.Position, Enemy.Position);
+            sqrDistance = Vector2.DistanceSquared(character.WorldPosition, Enemy.WorldPosition);
+            distanceTimer = distanceCheckInterval;
            if (WeaponComponent is MeleeWeapon meleeWeapon)
            {
                bool closeEnough = true;
                float sqrRange = meleeWeapon.Range * meleeWeapon.Range;
                if (character.AnimController.InWater)
                {
-                    if (sqrDist > sqrRange) 
+                    if (sqrDistance > sqrRange) 
                    {
                        closeEnough = false;
                    }
@@ -992,6 +1052,7 @@ namespace Barotrauma
                if (closeEnough)
                {
                    UseWeapon(deltaTime);
+                    character.AIController.SteeringManager.Reset();
                }
                else if (!character.IsFacing(Enemy.WorldPosition))
                {
@@ -1003,7 +1064,7 @@ namespace Barotrauma
            {
                if (WeaponComponent is RepairTool repairTool)
                {
-                    if (sqrDist > repairTool.Range * repairTool.Range) { return; }
+                    if (sqrDistance > repairTool.Range * repairTool.Range) { return; }
                }
                float aimFactor = MathHelper.PiOver2 * (1 - AimAccuracy);
                if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - Weapon.Position) < MathHelper.PiOver4 + aimFactor)
@@ -53,9 +53,13 @@ namespace Barotrauma
                    distanceFactor = 1;
                }
                float severity = AIObjectiveExtinguishFires.GetFireSeverity(targetHull);
-                if (severity > 0.5f && !isOrder)
+                if (severity > 0.75f && !isOrder && 
+                    targetHull.RoomName != null &&
+                    !targetHull.RoomName.Contains("reactor", StringComparison.OrdinalIgnoreCase) && 
+                    !targetHull.RoomName.Contains("engine", StringComparison.OrdinalIgnoreCase) && 
+                    !targetHull.RoomName.Contains("command", StringComparison.OrdinalIgnoreCase))
                {
-                    // Ignore severe fires unless ordered. (Let the fire drain all the oxygen instead).
+                    // Ignore severe fires to prevent casualities unless ordered to extinguish.
                    Priority = 0;
                    Abandon = true;
                }
@@ -25,7 +25,7 @@ namespace Barotrauma
        /// <summary>
        /// 0-1 based on the horizontal size of all of the fires in the hull.
        /// </summary>
-        public static float GetFireSeverity(Hull hull) => MathHelper.Lerp(0, 1, MathUtils.InverseLerp(0, Math.Min(hull.Rect.Width, 1000), hull.FireSources.Sum(fs => fs.Size.X)));
+        public static float GetFireSeverity(Hull hull) => MathHelper.Lerp(0, 1, MathUtils.InverseLerp(0, 500, hull.FireSources.Sum(fs => fs.Size.X)));

        protected override IEnumerable<Hull> GetList() => Hull.hullList;

@@ -56,13 +56,15 @@ namespace Barotrauma
        public static bool IsValidTarget(Character target, Character character)
        {
            if (target == null || target.Removed) { return false; }
-            if (target.IsDead || target.IsUnconscious) { return false; }
+            if (target.IsDead) { return false; }
+            if (target.IsUnconscious && target.Params.Health.ConstantHealthRegeneration <= 0.0f) { return false; }
            if (target == character) { return false; }
            if (target.Submarine == null) { return false; }
            if (character.Submarine == null) { return false; }
            if (target.CurrentHull == null) { return false; }
            if (HumanAIController.IsFriendly(character, target)) { return false; }
            if (!character.Submarine.IsConnectedTo(target.Submarine)) { return false; }
+            if (target.HasAbilityFlag(AbilityFlags.IgnoredByEnemyAI)) { return false; }
            return true;
        }
    }
@@ -39,6 +39,10 @@ namespace Barotrauma
                return;
            }
            targetItem = character.Inventory.FindItemByTag(gearTag, true);
+            if (targetItem == null && gearTag == LIGHT_DIVING_GEAR)
+            {
+                targetItem = character.Inventory.FindItemByTag(HEAVY_DIVING_GEAR, true);
+            }
            if (targetItem == null || !character.HasEquippedItem(targetItem, slotType: InvSlotType.OuterClothes | InvSlotType.Head | InvSlotType.InnerClothes) && targetItem.ContainedItems.Any(i => i.HasTag(OXYGEN_SOURCE) && i.Condition > 0))
            {
                TryAddSubObjective(ref getDivingGear, () =>
@@ -57,23 +61,37 @@ namespace Barotrauma
                    };
                }, 
                onAbandon: () => Abandon = true,
-                onCompleted: () => RemoveSubObjective(ref getDivingGear));
+                onCompleted: () =>
+                {
+                    RemoveSubObjective(ref getDivingGear);
+                    if (gearTag == HEAVY_DIVING_GEAR && HumanAIController.HasItem(character, LIGHT_DIVING_GEAR, out IEnumerable<Item> masks, requireEquipped: true))
+                    {
+                        foreach (Item mask in masks)
+                        {
+                            if (mask != targetItem)
+                            {
+                                character.Inventory.TryPutItem(mask, character, CharacterInventory.anySlot);
+                            }
+                        }
+                    }
+                });
            }
            else
            {
-                // Seek oxygen that has at least 10% condition left, if we are inside a friendly sub.
-                // The margin helps us to survive, because we might need some oxygen before we can find more oxygen.
-                // When we are venturing outside of our sub, let's just suppose that we have enough oxygen with us and optimize it so that we don't keep switching off half used tanks.
-                float min = character.Submarine != Submarine.MainSub ? 0.01f : MIN_OXYGEN;
+                float min = GetMinOxygen(character);
                if (targetItem.OwnInventory != null && targetItem.OwnInventory.AllItems.None(it => it != null && it.HasTag(OXYGEN_SOURCE) && it.Condition > min))
                {
                    TryAddSubObjective(ref getOxygen, () =>
                    {
                        if (character.IsOnPlayerTeam)
                        {
-                            if (HumanAIController.HasItem(character, "oxygensource", out _, conditionPercentage: min))
+                            if (HumanAIController.HasItem(character, OXYGEN_SOURCE, out _, conditionPercentage: min))
                            {
                                character.Speak(TextManager.Get("dialogswappingoxygentank"), null, 0, "swappingoxygentank", 30.0f);
+                                if (character.Inventory.FindAllItems(i => i.HasTag(OXYGEN_SOURCE) && i.Condition > min).Count == 1)
+                                {
+                                    character.Speak(TextManager.Get("dialoglastoxygentank"), null, 0.0f, "dialoglastoxygentank", 30.0f);
+                                }
                            }
                            else
                            {
@@ -105,7 +123,7 @@ namespace Barotrauma
                        onAbandon: () =>
                        {
                            Abandon = true;
-                            if (remainingTanks > 0 && !HumanAIController.HasItem(character, "oxygensource", out _, conditionPercentage: 0.01f))
+                            if (remainingTanks > 0 && !HumanAIController.HasItem(character, OXYGEN_SOURCE, out _, conditionPercentage: 0.01f))
                            {
                                character.Speak(TextManager.Get("dialogcantfindtoxygen"), null, 0, "cantfindoxygen", 30.0f);
                            }
@@ -121,7 +139,7 @@ namespace Barotrauma
                    int ReportOxygenTankCount()
                    {
                        if (character.Submarine != Submarine.MainSub) { return 1; }
-                        int remainingOxygenTanks = Submarine.MainSub.GetItems(false).Count(i => i.HasTag("oxygensource") && i.Condition > 1);
+                        int remainingOxygenTanks = Submarine.MainSub.GetItems(false).Count(i => i.HasTag(OXYGEN_SOURCE) && i.Condition > 1);
                        if (remainingOxygenTanks == 0)
                        {
                            character.Speak(TextManager.Get("DialogOutOfOxygenTanks"), null, 0.0f, "outofoxygentanks", 30.0f);
@@ -136,17 +154,6 @@ namespace Barotrauma
            }
        }

-        /// <summary>
-        /// Returns false only when no inventory can be found from the item.
-        /// </summary>
-        public static bool EjectEmptyTanks(Character actor, Item target, out IEnumerable<Item> containedItems)
-        {
-            containedItems = target.OwnInventory?.AllItems;
-            if (containedItems == null) { return false; }
-            AIController.UnequipEmptyItems(actor, target);
-            return true;
-        }
-
        public override void Reset()
        {
            base.Reset();
@@ -154,5 +161,20 @@ namespace Barotrauma
            getOxygen = null;
            targetItem = null;
        }
+
+        public static float GetMinOxygen(Character character)
+        {
+            // Seek oxygen that has at least 10% condition left, if we are inside a friendly sub.
+            // The margin helps us to survive, because we might need some oxygen before we can find more oxygen.
+            // When we are venturing outside of our sub, let's just suppose that we have enough oxygen with us and optimize it so that we don't keep switching off half used tanks.
+            float min = 0.01f;
+            float minOxygen = character.IsInFriendlySub ? MIN_OXYGEN : min;
+            if (minOxygen > min && character.Inventory.AllItems.Any(i => i.HasTag("oxygensource") && i.ConditionPercentage >= minOxygen))
+            {
+                // There's a valid oxygen tank in the inventory -> no need to swap the tank too early.
+                minOxygen = min;
+            }
+            return minOxygen;
+        }
    }
 }
@@ -46,20 +46,25 @@ namespace Barotrauma
            }
            if (character.CurrentHull == null)
            {
-                Priority = (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() || objectiveManager.HasActiveObjective<AIObjectiveCombat>()) && HumanAIController.HasDivingSuit(character) ? 0 : 100;
+                Priority = (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() ||
+                    objectiveManager.IsCurrentOrder<AIObjectiveReturn>() ||
+                    objectiveManager.Objectives.Any(o => o.Priority > 0 && o is AIObjectiveCombat))
+                    && HumanAIController.HasDivingSuit(character) ? 0 : 100;
            }
            else
            {
                if (HumanAIController.NeedsDivingGear(character.CurrentHull, out bool needsSuit) && 
                    (needsSuit ? 
-                    !HumanAIController.HasDivingSuit(character, conditionPercentage: AIObjectiveFindDivingGear.MIN_OXYGEN) : 
-                    !HumanAIController.HasDivingGear(character, conditionPercentage: AIObjectiveFindDivingGear.MIN_OXYGEN)))
+                    !HumanAIController.HasDivingSuit(character, conditionPercentage: AIObjectiveFindDivingGear.GetMinOxygen(character)) : 
+                    !HumanAIController.HasDivingGear(character, conditionPercentage: AIObjectiveFindDivingGear.GetMinOxygen(character))))
                {
                    Priority = 100;
                }
-                else if (objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() && character.Submarine != null && !HumanAIController.IsOnFriendlyTeam(character.TeamID, character.Submarine.TeamID))
+                else if ((objectiveManager.IsCurrentOrder<AIObjectiveGoTo>() || objectiveManager.IsCurrentOrder<AIObjectiveReturn>()) &&
+                         character.Submarine != null && !HumanAIController.IsOnFriendlyTeam(character.TeamID, character.Submarine.TeamID))
                {
-                    // Ordered to follow/hold position inside a hostile sub -> ignore find safety unless we need to find a diving gear
+                    // Ordered to follow, hold position, or return back to main sub inside a hostile sub
+                    // -> ignore find safety unless we need to find a diving gear
                    Priority = 0;
                }
                Priority = MathHelper.Clamp(Priority, 0, 100);
@@ -126,11 +131,11 @@ namespace Barotrauma
                bool needsEquipment = false;
                if (needsDivingSuit)
                {
-                    needsEquipment = !HumanAIController.HasDivingSuit(character, AIObjectiveFindDivingGear.MIN_OXYGEN);
+                    needsEquipment = !HumanAIController.HasDivingSuit(character, AIObjectiveFindDivingGear.GetMinOxygen(character));
                }
                else if (needsDivingGear)
                {
-                    needsEquipment = !HumanAIController.HasDivingGear(character, AIObjectiveFindDivingGear.MIN_OXYGEN);
+                    needsEquipment = !HumanAIController.HasDivingGear(character, AIObjectiveFindDivingGear.GetMinOxygen(character));
                }
                if (needsEquipment)
                {
@@ -298,17 +303,21 @@ namespace Barotrauma

            Hull bestHull = null;
            float bestValue = 0;
+            bool bestIsAirlock = false;
            foreach (Hull hull in Hull.hullList.OrderByDescending(h => EstimateHullSuitability(h)))
            {
                if (hull.Submarine == null) { continue; }
+                // Ruins are mazes filled with water. There's no safe hulls and we don't want to use the resources on it.
+                if (hull.Submarine.Info.IsRuin) { 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;
-                if (character.CurrentHull != null && character.Submarine != null)
+                bool hullIsAirlock = false;
+                bool isCharacterInside = character.CurrentHull != null && character.Submarine != null;
+                if (isCharacterInside)
                {
-                    // Inside
                    if (!character.Submarine.IsConnectedTo(hull.Submarine)) { continue; }
                    hullSafety = HumanAIController.GetHullSafety(hull, hull.GetConnectedHulls(true, 1), character);
                    float yDist = Math.Abs(character.WorldPosition.Y - hull.WorldPosition.Y);
@@ -325,7 +334,7 @@ namespace Barotrauma
                        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);
+                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, hull.SimPosition, character.Submarine, nodeFilter: node => node.Waypoint.CurrentHull != null);
                    if (path.Unreachable)
                    {
                        HumanAIController.UnreachableHulls.Add(hull);
@@ -343,24 +352,16 @@ namespace Barotrauma
                }
                else
                {
-                    // Outside
-                    if (hull.RoomName != null && hull.RoomName.Contains("airlock", StringComparison.OrdinalIgnoreCase))
+                    // TODO: could also target gaps that get us inside?
+                    if (hull.IsTaggedAirlock())
+                    {
+                        hullSafety = 100;
+                        hullIsAirlock = true;
+                    }
+                    else if(!bestIsAirlock && hull.LeadsOutside(character))
                    {
                        hullSafety = 100;
                    }
-                    else
-                    {
-                        // TODO: could also target gaps that get us inside?
-                        foreach (Item item in Item.ItemList)
-                        {
-                            if (item.CurrentHull != hull && item.HasTag("airlock"))
-                            {
-                                hullSafety = 100;
-                                break;
-                            }
-                        }
-                    }
-                    // TODO: could we get a closest door to the outside and target the flowing hull if no airlock is found?
                    // Huge preference for closer targets
                    float distance = Vector2.DistanceSquared(character.WorldPosition, hull.WorldPosition);
                    float distanceFactor = MathHelper.Lerp(1, 0.2f, MathUtils.InverseLerp(0, MathUtils.Pow(100000, 2), distance));
@@ -372,10 +373,11 @@ namespace Barotrauma
                        hullSafety /= 10;
                    }
                }
-                if (hullSafety > bestValue)
+                if (hullSafety > bestValue || (!isCharacterInside && hullIsAirlock && !bestIsAirlock))
                {
                    bestHull = hull;
                    bestValue = hullSafety;
+                    bestIsAirlock = hullIsAirlock;
                }
            }
            return bestHull;
@@ -323,7 +323,7 @@ namespace Barotrauma
                    // This is relatively expensive, so let's do this only when it significantly improves the behavior.
                    // Only allow one path find call per frame.
                    hasCalledPathFinder = true;
-                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, item.SimPosition, errorMsgStr: $"AIObjectiveGetItem {character.DisplayName}", nodeFilter: node => node.Waypoint.CurrentHull != null);
+                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, item.SimPosition, character.Submarine, errorMsgStr: $"AIObjectiveGetItem {character.DisplayName}", nodeFilter: node => node.Waypoint.CurrentHull != null);
                    if (path.Unreachable) { continue; }
                }
                currItemPriority = itemPriority;
@@ -27,6 +27,7 @@ namespace Barotrauma
        public bool followControlledCharacter;
        public bool mimic;
        public bool SpeakIfFails { get; set; } = true;
+        public bool UsePathingOutside { get; set; } = true;

        public float extraDistanceWhileSwimming;
        public float extraDistanceOutsideSub;
@@ -121,13 +122,14 @@ namespace Barotrauma
        }

        private readonly float avoidLookAheadDistance = 5;
+        private readonly float pathWaitingTime = 3;

        public AIObjectiveGoTo(ISpatialEntity target, Character character, AIObjectiveManager objectiveManager, bool repeat = false, bool getDivingGearIfNeeded = true, float priorityModifier = 1, float closeEnough = 0)
            : base(character, objectiveManager, priorityModifier)
        {
            Target = target;
            this.repeat = repeat;
-            waitUntilPathUnreachable = 3.0f;
+            waitUntilPathUnreachable = pathWaitingTime;
            this.getDivingGearIfNeeded = getDivingGearIfNeeded;
            if (Target is Item i)
            {
@@ -159,6 +161,8 @@ namespace Barotrauma
            }
        }

+        public void ForceAct(float deltaTime) => Act(deltaTime);
+
        protected override void Act(float deltaTime)
        {
            if (followControlledCharacter)
@@ -184,7 +188,6 @@ namespace Barotrauma
                // Wait
                character.AIController.SteeringManager.Reset();
            }
-            waitUntilPathUnreachable -= deltaTime;
            if (!character.IsClimbing)
            {
                character.SelectedConstruction = null;
@@ -220,11 +223,13 @@ namespace Barotrauma
            {
                Abandon = true;
            }
-            else if (SteeringManager == PathSteering && PathSteering.CurrentPath != null && PathSteering.CurrentPath.Unreachable && !PathSteering.IsPathDirty)
+            else if (HumanAIController.IsCurrentPathUnreachable)
            {
+                waitUntilPathUnreachable -= deltaTime;
                SteeringManager.Reset();
                if (waitUntilPathUnreachable < 0)
                {
+                    waitUntilPathUnreachable = pathWaitingTime;
                    if (repeat)
                    {
                        SpeakCannotReach();
@@ -240,7 +245,7 @@ namespace Barotrauma
                if (getDivingGearIfNeeded && !character.LockHands)
                {
                    Character followTarget = Target as Character;
-                    bool needsDivingSuit = targetIsOutside;
+                    bool needsDivingSuit = !isInside || targetIsOutside;
                    bool needsDivingGear = needsDivingSuit || HumanAIController.NeedsDivingGear(targetHull, out needsDivingSuit);
                    if (mimic)
                    {
@@ -255,7 +260,7 @@ namespace Barotrauma
                        }
                    }
                    bool needsEquipment = false;
-                    float minOxygen = character.Submarine == null ? 0 : AIObjectiveFindDivingGear.MIN_OXYGEN;
+                    float minOxygen = AIObjectiveFindDivingGear.GetMinOxygen(character);
                    if (needsDivingSuit)
                    {
                        needsEquipment = !HumanAIController.HasDivingSuit(character, minOxygen);
@@ -323,25 +328,29 @@ namespace Barotrauma
                        }
                        else
                        {
-                            SeekGaps(maxGapDistance);
-                            seekGapsTimer = seekGapsInterval * Rand.Range(0.1f, 1.1f);
-                            if (TargetGap != null)
+                            bool isRuins = character.Submarine?.Info.IsRuin != null || Target.Submarine?.Info.IsRuin != null;
+                            if (!isRuins || !HumanAIController.HasValidPath(requireNonDirty: true, requireUnfinished: true))
                            {
-                                // Check that nothing is blocking the way
-                                Vector2 rayStart = character.SimPosition;
-                                Vector2 rayEnd = TargetGap.SimPosition;
-                                if (TargetGap.Submarine != null && character.Submarine == null)
+                                SeekGaps(maxGapDistance);
+                                seekGapsTimer = seekGapsInterval * Rand.Range(0.1f, 1.1f);
+                                if (TargetGap != null)
                                {
-                                    rayStart -= TargetGap.Submarine.SimPosition;
-                                }
-                                else if (TargetGap.Submarine == null && character.Submarine != null)
-                                {
-                                    rayEnd -= character.Submarine.SimPosition;
-                                }
-                                var closestBody = Submarine.CheckVisibility(rayStart, rayEnd, ignoreSubs: true);
-                                if (closestBody != null)
-                                {
-                                    TargetGap = null;
+                                    // Check that nothing is blocking the way
+                                    Vector2 rayStart = character.SimPosition;
+                                    Vector2 rayEnd = TargetGap.SimPosition;
+                                    if (TargetGap.Submarine != null && character.Submarine == null)
+                                    {
+                                        rayStart -= TargetGap.Submarine.SimPosition;
+                                    }
+                                    else if (TargetGap.Submarine == null && character.Submarine != null)
+                                    {
+                                        rayEnd -= character.Submarine.SimPosition;
+                                    }
+                                    var closestBody = Submarine.CheckVisibility(rayStart, rayEnd, ignoreSubs: true);
+                                    if (closestBody != null)
+                                    {
+                                        TargetGap = null;
+                                    }
                                }
                            }
                        }
@@ -365,7 +374,7 @@ namespace Barotrauma
                    if (checkScooterTimer <= 0)
                    {
                        useScooter = false;
-                        checkScooterTimer = checkScooterTime;
+                        checkScooterTimer = checkScooterTime * Rand.Range(0.75f, 1.25f);
                        string scooterTag = "scooter";
                        string batteryTag = "mobilebattery";
                        Item scooter = null;
@@ -444,18 +453,33 @@ namespace Barotrauma
                }
                if (SteeringManager == PathSteering)
                {
+                    Vector2 targetPos = character.GetRelativeSimPosition(Target);
                    Func<PathNode, bool> nodeFilter = null;
                    if (isInside && !AllowGoingOutside)
                    {
                        nodeFilter = n => n.Waypoint.CurrentHull != null;
                    }
+                    else if (!isInside && HumanAIController.UseIndoorSteeringOutside)
+                    {
+                        nodeFilter = n => n.Waypoint.Submarine == null;
+                    }

-                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(Target), 1, 
-                        startNodeFilter: n => (n.Waypoint.CurrentHull == null) == (character.CurrentHull == null), 
-                        endNodeFilter, 
-                        nodeFilter, 
-                        CheckVisibility);
-
+                    if (!isInside && !UsePathingOutside)
+                    {
+                        PathSteering.SteeringSeekSimple(character.GetRelativeSimPosition(Target), 10);
+                        if (character.AnimController.InWater)
+                        {
+                            SteeringManager.SteeringAvoid(deltaTime, avoidLookAheadDistance, weight: 15);
+                        }
+                    }
+                    else
+                    {
+                        PathSteering.SteeringSeek(targetPos, weight: 1,
+                            startNodeFilter: n => (n.Waypoint.CurrentHull == null) == (character.CurrentHull == null),
+                            endNodeFilter: endNodeFilter,
+                            nodeFilter: nodeFilter,
+                            checkVisiblity: CheckVisibility);
+                    }
                    if (!isInside && (PathSteering.CurrentPath == null || PathSteering.IsPathDirty || PathSteering.CurrentPath.Unreachable))
                    {
                        if (useScooter)
@@ -501,9 +525,22 @@ namespace Barotrauma
                {
                    character.CursorPosition -= character.Submarine.Position;
                }
-                Vector2 dir = Vector2.Normalize(character.CursorPosition - character.Position);
-                if (!MathUtils.IsValid(dir)) { dir = Vector2.UnitY; }
-                SteeringManager.SteeringManual(1.0f, dir);
+                Vector2 diff = character.CursorPosition - character.Position;
+                Vector2 dir = Vector2.Normalize(diff);
+                float sqrDist = diff.LengthSquared();
+                if (sqrDist > MathUtils.Pow2(CloseEnough * 1.5f))
+                {
+                    SteeringManager.SteeringManual(1.0f, dir);
+                }
+                else
+                {
+                    float dot = Vector2.Dot(dir, VectorExtensions.Forward(character.AnimController.Collider.Rotation + MathHelper.PiOver2));
+                    bool isFacing = dot > 0.9f;
+                    if (!isFacing && sqrDist > MathUtils.Pow2(CloseEnough))
+                    {
+                        SteeringManager.SteeringManual(1.0f, dir);
+                    }
+                }
                character.SetInput(InputType.Aim, false, true);
                character.SetInput(InputType.Shoot, false, true);
            }
@@ -511,7 +548,7 @@ namespace Barotrauma

        private bool useScooter;
        private float checkScooterTimer;
-        private readonly float checkScooterTime = 0.2f;
+        private readonly float checkScooterTime = 0.5f;

        public Hull GetTargetHull() => GetTargetHull(Target);

@@ -242,9 +242,8 @@ namespace Barotrauma
                    if (!searchingNewHull)
                    {
                        //find all available hulls first
-                        FindTargetHulls();
                        searchingNewHull = true;
-                        return;
+                        FindTargetHulls();
                    }
                    else if (targetHulls.Any())
                    {
@@ -252,14 +251,13 @@ namespace Barotrauma
                        currentTarget = ToolBox.SelectWeightedRandom(targetHulls, hullWeights, Rand.RandSync.Unsynced);
                        bool isInWrongSub = (character.TeamID == CharacterTeamType.FriendlyNPC && !character.IsEscorted) && character.Submarine.TeamID != character.TeamID;
                        bool isCurrentHullAllowed = !isInWrongSub && !IsForbidden(character.CurrentHull);
-                        var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: null, nodeFilter: node =>
+                        var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, character.Submarine, nodeFilter: node =>
                        {
                            if (node.Waypoint.CurrentHull == null) { return false; }
-                            // Check that there is no unsafe or forbidden hulls on the way to the target
+                            // Check that there is no unsafe 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;
-                        });
+                        }, endNodeFilter: node => !isCurrentHullAllowed | !IsForbidden(node.Waypoint.CurrentHull));
                        if (path.Unreachable)
                        {
                            //can't go to this room, remove it from the list and try another room
@@ -271,31 +269,20 @@ namespace Barotrauma
                            SetTargetTimerLow();
                            return;
                        }
+                        character.AIController.SelectTarget(currentTarget.AiTarget);
+                        PathSteering.SetPath(path);
+                        SetTargetTimerNormal();
                        searchingNewHull = false;
                    }
                    else
                    {
-                        // Couldn't find a target for some reason -> reset
+                        // Couldn't find a valid hull
                        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);
-                    }
-                    SetTargetTimerNormal();
                }
                newTargetTimer -= deltaTime;
-
-                if (!character.IsClimbing && IsSteeringFinished())
+                if (!character.IsClimbing && (PathSteering == null || PathSteering.CurrentPath == null || IsSteeringFinished()))
                {
                    Wander(deltaTime);
                }
@@ -406,9 +393,10 @@ namespace Barotrauma
            hullWeights.Clear();
            foreach (var hull in Hull.hullList)
            {
+                if (character.Submarine == null) { break; }
                if (HumanAIController.UnsafeHulls.Contains(hull)) { continue; }
                if (hull.Submarine == null) { continue; }
-                if (character.Submarine == null) { break; }
+                if (hull.Submarine.Info.IsRuin || hull.Submarine.Info.IsWreck) { continue; }
                if (character.TeamID == CharacterTeamType.FriendlyNPC && !character.IsEscorted)
                {
                    if (hull.Submarine.TeamID != character.TeamID)
@@ -163,7 +163,7 @@ namespace Barotrauma
                CoroutineManager.StopCoroutines(coroutine);
                DelayedObjectives.Remove(objective);
            }
-            coroutine = CoroutineManager.InvokeAfter(() =>
+            coroutine = CoroutineManager.Invoke(() =>
            {
                //round ended before the coroutine finished
 #if CLIENT
@@ -233,11 +233,7 @@ namespace Barotrauma
                if (orderObjective == null) { return; }
 #if DEBUG
                // Note: don't automatically remove orders here. Removing orders needs to be done via dismissing.
-                if (orderObjective.IsCompleted)
-                {
-                    DebugConsole.NewMessage($"{character.Name}: ORDER {orderObjective.DebugTag} IS COMPLETED. CURRENTLY ALL ORDERS SHOULD BE LOOPING.", Color.Red);
-                }
-                else if (!orderObjective.CanBeCompleted)
+                if (!orderObjective.CanBeCompleted)
                {
                    DebugConsole.NewMessage($"{character.Name}: ORDER {orderObjective.DebugTag}, CANNOT BE COMPLETED.", Color.Red);
                }
@@ -281,9 +277,9 @@ namespace Barotrauma
            ForcedOrder?.CalculatePriority();
            AIObjective orderWithHighestPriority = null;
            float highestPriority = 0;
-            foreach (var currentOrder in CurrentOrders)
+            for (int i = CurrentOrders.Count - 1; i >= 0; i--)
            {
-                var orderObjective = currentOrder.Objective;
+                var orderObjective = CurrentOrders[i].Objective;
                if (orderObjective == null) { continue; }
                orderObjective.CalculatePriority();
                if (orderWithHighestPriority == null || orderObjective.Priority > highestPriority)
@@ -467,6 +463,11 @@ namespace Barotrauma
                        AllowGoingOutside = character.Submarine == null || (order.TargetSpatialEntity != null && character.Submarine != order.TargetSpatialEntity.Submarine)
                    };
                    break;
+                case "return":
+                    newObjective = new AIObjectiveReturn(character, orderGiver, this, priorityModifier: priorityModifier);
+                    newObjective.Abandoned += () => DismissSelf(order, option);
+                    newObjective.Completed += () => DismissSelf(order, option);
+                    break;
                case "fixleaks":
                    newObjective = new AIObjectiveFixLeaks(character, this, priorityModifier: priorityModifier, prioritizedHull: order.TargetEntity as Hull);
                    break;
@@ -586,6 +587,27 @@ namespace Barotrauma
            return newObjective;
        }

+        private void DismissSelf(Order order, string option)
+        {
+            var currentOrder = CurrentOrders.FirstOrDefault(oi => oi.MatchesOrder(order, option));
+            if (currentOrder.Order == null)
+            {
+#if DEBUG
+                DebugConsole.ThrowError("Tried to self-dismiss an order, but no matching current order was found");
+#endif
+                return;
+            }
+#if CLIENT
+            if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
+            {
+                GameMain.GameSession?.CrewManager?.SetCharacterOrder(character, Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, character);
+            }
+#else
+            GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, currentOrder.Order?.TargetSpatialEntity, character, character));
+#endif
+        }
+
+
        private bool IsAllowedToWait()
        {
            if (!character.IsOnPlayerTeam) { return false; }
@@ -606,6 +628,8 @@ namespace Barotrauma
        public bool IsActiveObjective<T>() where T : AIObjective => GetActiveObjective() is T;

        public AIObjective GetActiveObjective() => CurrentObjective?.GetActiveObjective();
+        public T GetOrder<T>() where T : AIObjective => CurrentOrders.FirstOrDefault(o => o.Objective is T).Objective as T;
+
        /// <summary>
        /// Returns the last active objective of the specific type.
        /// </summary>
@@ -408,7 +408,7 @@ namespace Barotrauma
            }
            bool isCompleted = 
                AIObjectiveRescueAll.GetVitalityFactor(targetCharacter) >= AIObjectiveRescueAll.GetVitalityThreshold(objectiveManager, character, targetCharacter) ||
-                targetCharacter.CharacterHealth.GetAllAfflictions().All(a => a.Strength < a.Prefab.TreatmentThreshold);
+                targetCharacter.CharacterHealth.GetAllAfflictions().All(a => a.Strength <= a.Prefab.TreatmentThreshold);

            if (isCompleted && targetCharacter != character && character.IsOnPlayerTeam)
            {                
@@ -83,7 +83,7 @@ namespace Barotrauma
            if (character.AIController is HumanAIController humanAI)
            {
                if (GetVitalityFactor(target) >= GetVitalityThreshold(humanAI.ObjectiveManager, character, target) ||
-                    target.CharacterHealth.GetAllAfflictions().All(a => a.Strength < a.Prefab.TreatmentThreshold)) 
+                    target.CharacterHealth.GetAllAfflictions().All(a => a.Strength <= a.Prefab.TreatmentThreshold)) 
                {
                    return false; 
                }
@@ -0,0 +1,273 @@
+using Barotrauma.Extensions;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class AIObjectiveReturn : AIObjective
+    {
+        public override string Identifier { get; set; } = "return";
+        private AIObjectiveGoTo moveInsideObjective, moveInCaveObjective, moveOutsideObjective;
+        private bool usingEscapeBehavior;
+        private bool isSteeringThroughGap;
+        public Submarine ReturnTarget { get; }
+
+        public AIObjectiveReturn(Character character, Character orderGiver, AIObjectiveManager objectiveManager, float priorityModifier = 1.0f) : base(character, objectiveManager, priorityModifier)
+        {
+            ReturnTarget = GetReturnTarget(Submarine.MainSubs) ?? GetReturnTarget(Submarine.Loaded);
+            if (ReturnTarget == null)
+            {
+                DebugConsole.ThrowError("Error with a Return objective: no suitable return target found");
+                Abandon = true;
+            }
+
+            Submarine GetReturnTarget(IEnumerable<Submarine> subs)
+            {
+                var requiredTeamID = orderGiver?.TeamID ?? character?.TeamID;
+                Submarine returnTarget = null;
+                foreach (var sub in subs)
+                {
+                    if (sub == null) { continue; }
+                    if (sub.TeamID != requiredTeamID) { continue; }
+                    returnTarget = sub;
+                    break;
+                }
+                return returnTarget;
+            }
+        }
+
+        protected override float GetPriority()
+        {
+            if (!Abandon && !IsCompleted && objectiveManager.IsOrder(this))
+            {
+                Priority = objectiveManager.GetOrderPriority(this);
+            }
+            else
+            {
+                // TODO: Consider if this needs to be addressed
+                Priority = 0;
+            }
+            return Priority;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            if (ReturnTarget == null)
+            {
+                Abandon = true;
+                return;
+            }
+            bool shouldUseEscapeBehavior = false;
+            if (character.CurrentHull != null || isSteeringThroughGap)
+            {
+                if (character.Submarine == null || !character.Submarine.IsConnectedTo(ReturnTarget))
+                {
+                    // Character is on another sub that is not connected to the target sub, use the escape behavior to get them out
+                    shouldUseEscapeBehavior = true;
+                    if (!usingEscapeBehavior)
+                    {
+                        HumanAIController.ResetEscape();
+                    }
+                    isSteeringThroughGap = HumanAIController.Escape(deltaTime);
+                    if (!isSteeringThroughGap && (HumanAIController.EscapeTarget == null || HumanAIController.IsCurrentPathUnreachable))
+                    {
+                        Abandon = true;
+                    }
+                }
+                else if (character.Submarine != ReturnTarget)
+                {
+                    // Character is on another sub that is connected to the target sub, create a Go To objective to reach the target sub
+                    if (moveInsideObjective == null)
+                    {
+                        Hull targetHull = null;
+                        foreach (var d in ReturnTarget.ConnectedDockingPorts.Values)
+                        {
+                            if (!d.Docked) { continue; }
+                            if (d.DockingTarget == null) { continue; }
+                            if (d.DockingTarget.Item.Submarine != character.Submarine) { continue; }
+                            targetHull = d.Item.CurrentHull;
+                            break;
+                        }
+                        if (targetHull != null && !targetHull.IsTaggedAirlock())
+                        {
+                            // Target the closest airlock
+                            float closestDist = 0;
+                            Hull airlock = null;
+                            foreach (Hull hull in Hull.hullList)
+                            {
+                                if (hull.Submarine != targetHull.Submarine) { continue; }
+                                if (!hull.IsTaggedAirlock()) { continue; }
+                                float dist = Vector2.DistanceSquared(targetHull.Position, hull.Position);
+                                if (airlock == null || closestDist <= 0 || dist < closestDist)
+                                {
+                                    airlock = hull;
+                                    closestDist = dist;
+                                }
+                                
+                            }
+                            if (airlock != null)
+                            {
+                                targetHull = airlock;
+                            }
+                        }
+                        if (targetHull != null)
+                        {
+                            RemoveSubObjective(ref moveInCaveObjective);
+                            RemoveSubObjective(ref moveOutsideObjective);
+                            TryAddSubObjective(ref moveInsideObjective,
+                                constructor: () => new AIObjectiveGoTo(targetHull, character, objectiveManager)
+                                {
+                                    AllowGoingOutside = true,
+                                    endNodeFilter = n => n.Waypoint.Submarine == targetHull.Submarine
+                                },
+                                onCompleted: () => RemoveSubObjective(ref moveInsideObjective),
+                                onAbandon: () => Abandon = true);
+                        }
+                        else
+                        {
+#if DEBUG
+                            DebugConsole.ThrowError("Error with a Return objective: no suitable target for 'moveInsideObjective'");
+#endif
+                        }
+                    }
+                }
+                else
+                {
+                    // Character is on the target sub, the objective is completed
+                    IsCompleted = true;
+                }
+            }
+            else if (!isSteeringThroughGap && moveInCaveObjective == null && moveOutsideObjective == null)
+            {
+                if (HumanAIController.IsInsideCave)
+                {
+                    WayPoint closestOutsideWaypoint = null;
+                    float closestDistance = float.MaxValue;
+                    foreach (var w in WayPoint.WayPointList)
+                    {
+                        if (w.Tunnel != null && w.Tunnel.Type == Level.TunnelType.Cave) { continue; }
+                        if (w.linkedTo.None(l => l is WayPoint linkedWaypoint && linkedWaypoint.Tunnel?.Type == Level.TunnelType.Cave)) { continue; }
+                        float distance = Vector2.DistanceSquared(character.WorldPosition, w.WorldPosition);
+                        if (closestOutsideWaypoint == null || distance < closestDistance)
+                        {
+                            closestOutsideWaypoint = w;
+                            closestDistance = distance;
+                        }
+                    }
+                    if (closestOutsideWaypoint != null)
+                    {
+                        RemoveSubObjective(ref moveInsideObjective);
+                        RemoveSubObjective(ref moveOutsideObjective);
+                        TryAddSubObjective(ref moveInCaveObjective,
+                            constructor: () => new AIObjectiveGoTo(closestOutsideWaypoint, character, objectiveManager)
+                            {
+                                endNodeFilter = n => n.Waypoint == closestOutsideWaypoint,
+                                AllowGoingOutside = true
+                            },
+                            onCompleted: () => RemoveSubObjective(ref moveInCaveObjective),
+                            onAbandon: () => Abandon = true);
+                    }
+                    else
+                    {
+#if DEBUG
+                        DebugConsole.ThrowError("Error with a Return objective: no suitable main or side path node target found for 'moveOutsideObjective'");
+#endif
+                    }
+                }
+                else
+                {
+                    Hull targetHull = null;
+                    float targetDistanceSquared = float.MaxValue;
+                    bool targetIsAirlock = false;
+                    foreach (var hull in ReturnTarget.GetHulls(false))
+                    {
+                        bool hullIsAirlock = hull.IsTaggedAirlock();
+                        if(hullIsAirlock || (!targetIsAirlock && hull.LeadsOutside(character)))
+                        {
+                            float distanceSquared = Vector2.DistanceSquared(character.WorldPosition, hull.WorldPosition);
+                            if (targetHull == null || distanceSquared < targetDistanceSquared)
+                            {
+                                targetHull = hull;
+                                targetDistanceSquared = distanceSquared;
+                                targetIsAirlock = hullIsAirlock;
+                            }
+                        }
+                    }
+                    if (targetHull != null)
+                    {
+                        RemoveSubObjective(ref moveInsideObjective);
+                        RemoveSubObjective(ref moveInCaveObjective);
+                        TryAddSubObjective(ref moveOutsideObjective,
+                            constructor: () => new AIObjectiveGoTo(targetHull, character, objectiveManager)
+                            {
+                                AllowGoingOutside = true
+                            },
+                            onCompleted: () => RemoveSubObjective(ref moveOutsideObjective),
+                            onAbandon: () => Abandon = true);
+                    }
+                    else
+                    {
+#if DEBUG
+                        DebugConsole.ThrowError("Error with a Return objective: no suitable target for 'moveOutsideObjective'");
+#endif
+                    }
+                }
+            }
+            else
+            {
+                if (HumanAIController.IsInsideCave)
+                {
+                    RemoveSubObjective(ref moveOutsideObjective);
+                }
+                else
+                {
+                    RemoveSubObjective(ref moveInCaveObjective);
+                }
+            }
+            usingEscapeBehavior = shouldUseEscapeBehavior;
+        }
+
+        protected override bool CheckObjectiveSpecific()
+        {
+            if (IsCompleted)
+            {
+                return true;
+            }
+            if (ReturnTarget == null)
+            {
+                Abandon = true;
+                return false;
+            }
+            if (character.Submarine == ReturnTarget)
+            {
+                IsCompleted = true;
+            }
+            return IsCompleted;
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            moveInsideObjective = null;
+            moveInCaveObjective = null;
+            moveOutsideObjective = null;
+            usingEscapeBehavior = false;
+            isSteeringThroughGap = false;
+            HumanAIController.ResetEscape();
+        }
+
+        protected override void OnAbandon()
+        {
+            base.OnAbandon();
+            SteeringManager?.Reset();
+            if (character.IsOnPlayerTeam && objectiveManager.CurrentOrder == objectiveManager.CurrentObjective)
+            {
+                string msg = TextManager.Get("dialogcannotreturn", returnNull: true);
+                if (msg != null)
+                {
+                    character.Speak(msg, identifier: "dialogcannotreturn", minDurationBetweenSimilar: 5.0f);
+                }
+            }
+        }
+    }
+}