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

2022-06-15 13:26:49 -03:00
parent efd1243754 08cc2faec8
commit 7a09711296
410 changed files with 11140 additions and 5815 deletions
@@ -245,7 +245,7 @@ namespace Barotrauma
        {
            get 
            {
-                if (IgnoreAtOutpost && Level.IsLoadedOutpost && character.TeamID != CharacterTeamType.FriendlyNPC)
+                if (IgnoreAtOutpost && Level.IsLoadedFriendlyOutpost && character.TeamID != CharacterTeamType.FriendlyNPC)
                {
                    if (Submarine.MainSub != null && Submarine.MainSub.DockedTo.None(s => s.TeamID != CharacterTeamType.FriendlyNPC && s.TeamID != character.TeamID))
                    {
@@ -2,7 +2,6 @@
 using Barotrauma.Items.Components;
 using System.Collections.Generic;
 using System.Linq;
-using System;

 namespace Barotrauma
 {
@@ -48,6 +47,9 @@ namespace Barotrauma

        protected override bool Filter(Item target)
        {
+            System.Diagnostics.Debug.Assert(target.GetComponent<Pickable>() is { } pickable && !pickable.IsAttached, "Invalid target in AIObjectiveCleanUpItems - the the objective should only be checking pickable, non-attached items.");
+            System.Diagnostics.Debug.Assert(target.Prefab.PreferredContainers.Any(), "Invalid target in AIObjectiveCleanUpItems - the the objective should only be checking items that have preferred containers defined.");
+
            // If the target was selected as a valid target, we'll have to accept it so that the objective can be completed.
            // The validity changes when a character picks the item up.
            if (!IsValidTarget(target, character, checkInventory: true)) { return Objectives.ContainsKey(target) && IsItemInsideValidSubmarine(target, character); }
@@ -57,7 +59,7 @@ namespace Barotrauma
            return true;
        }

-        protected override IEnumerable<Item> GetList() => Item.ItemList;
+        protected override IEnumerable<Item> GetList() => Item.CleanableItems;

        protected override AIObjective ObjectiveConstructor(Item item)
            => new AIObjectiveCleanupItem(item, character, objectiveManager, priorityModifier: PriorityModifier)
@@ -102,9 +104,6 @@ namespace Barotrauma
            }
            if (character != null && !IsItemInsideValidSubmarine(item, character)) { return false; }
            if (item.HasBallastFloraInHull) { return false; }
-            var pickable = item.GetComponent<Pickable>();
-            if (pickable == null) { return false; }
-            if (pickable is Holdable h && h.Attachable && h.Attached) { return false; }
            var wire = item.GetComponent<Wire>();
            if (wire != null)
            {
@@ -113,15 +112,11 @@ namespace Barotrauma
            else
            {
                var connectionPanel = item.GetComponent<ConnectionPanel>();
-                if (connectionPanel != null && connectionPanel.Connections.Any(c => c.Wires.Any(w => w != null)))
+                if (connectionPanel != null && connectionPanel.Connections.Any(c => c.Wires.Count > 0))
                {
                    return false;
                }
            }
-            if (item.Prefab.PreferredContainers.None())
-            {
-                return false;
-            }
            if (!checkInventory)
            {
                return true;
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using FarseerPhysics.Dynamics;
+using static Barotrauma.AIObjectiveFindSafety;

 namespace Barotrauma
 {
@@ -775,7 +776,13 @@ namespace Barotrauma
                }
                else
                {
-                    retreatTarget = findSafety.FindBestHull(HumanAIController.VisibleHulls, allowChangingTheSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
+                    HullSearchStatus hullSearchStatus = findSafety.FindBestHull(out Hull potentialSafeHull, HumanAIController.VisibleHulls, allowChangingSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
+                    if (hullSearchStatus != HullSearchStatus.Finished)
+                    {
+                        findSafety.UpdateSimpleEscape(deltaTime);
+                        return;
+                    }
+                    retreatTarget = potentialSafeHull;
                    findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
                }
            }
@@ -785,21 +792,21 @@ namespace Barotrauma
                {
                    UsePathingOutside = false
                },
-                    onAbandon: () =>
+                onAbandon: () =>
+                {
+                    if (Enemy != null && HumanAIController.VisibleHulls.Contains(Enemy.CurrentHull))
                    {
-                        if (Enemy != null && HumanAIController.VisibleHulls.Contains(Enemy.CurrentHull))
-                        {
-                            // If in the same room with an enemy -> don't try to escape because we'd want to fight it
-                            SteeringManager.Reset();
-                            RemoveSubObjective(ref retreatObjective);
-                        }
-                        else
-                        {
-                            // else abandon and fall back to find safety mode
-                            Abandon = true;
-                        }
-                    }, 
-                    onCompleted: () => RemoveSubObjective(ref retreatObjective));
+                        // If in the same room with an enemy -> don't try to escape because we'd want to fight it
+                        SteeringManager.Reset();
+                        RemoveSubObjective(ref retreatObjective);
+                    }
+                    else
+                    {
+                        // else abandon and fall back to find safety mode
+                        Abandon = true;
+                    }
+                }, 
+                onCompleted: () => RemoveSubObjective(ref retreatObjective));
            }
        }

@@ -1,4 +1,5 @@
-using FarseerPhysics;
+using Barotrauma.Extensions;
+using FarseerPhysics;
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
@@ -192,9 +193,17 @@ namespace Barotrauma
                }
                else
                {
+                    HullSearchStatus hullSearchStatus = FindBestHull(out Hull potentialSafeHull, allowChangingSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
+                    if (hullSearchStatus != HullSearchStatus.Finished)
+                    {
+                        UpdateSimpleEscape(deltaTime);
+                        return;
+                    }
+
                    searchHullTimer = SearchHullInterval * Rand.Range(0.9f, 1.1f);
                    previousSafeHull = currentSafeHull;
-                    currentSafeHull = FindBestHull(allowChangingTheSubmarine: character.TeamID != CharacterTeamType.FriendlyNPC);
+                    currentSafeHull = potentialSafeHull;
+
                    cannotFindSafeHull = currentSafeHull == null || HumanAIController.NeedsDivingGear(currentSafeHull, out _);
                    if (currentSafeHull == null)
                    {
@@ -250,58 +259,122 @@ namespace Barotrauma
                    }
                }
                if (subObjectives.Any(so => so.CanBeCompleted)) { return; }
-                if (currentHull != null)
+                UpdateSimpleEscape(deltaTime);
+            }
+        }
+
+        public void UpdateSimpleEscape(float deltaTime)
+        {
+            Vector2 escapeVel = Vector2.Zero;
+            if (character.CurrentHull != null)
+            {
+                foreach (Hull hull in HumanAIController.VisibleHulls)
                {
-                    //goto objective doesn't exist (a safe hull not found, or a path to a safe hull not found)
-                    // -> attempt to manually steer away from hazards
-                    Vector2 escapeVel = Vector2.Zero;
-                    foreach (Hull hull in HumanAIController.VisibleHulls)
+                    foreach (FireSource fireSource in hull.FireSources)
                    {
-                        foreach (FireSource fireSource in hull.FireSources)
-                        {
-                            Vector2 dir = character.Position - fireSource.Position;
-                            float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(fireSource.Position, character.Position), 0.1f, 10.0f);
-                            escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
-                        }
-                    }
-                    foreach (Character enemy in Character.CharacterList)
-                    {
-                        if (!HumanAIController.IsActive(enemy) || HumanAIController.IsFriendly(enemy) || enemy.IsArrested) { continue; }
-                        if (HumanAIController.VisibleHulls.Contains(enemy.CurrentHull))
-                        {
-                            Vector2 dir = character.Position - enemy.Position;
-                            float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(enemy.Position, character.Position), 0.1f, 10.0f);
-                            escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
-                        }
-                    }
-                    if (escapeVel != Vector2.Zero)
-                    {
-                        float left = currentHull.Rect.X + 50;
-                        float right = currentHull.Rect.Right - 50;
-                        //only move if we haven't reached the edge of the room
-                        if (escapeVel.X < 0 && character.Position.X > left || escapeVel.X > 0 && character.Position.X < right)
-                        {
-                            character.AIController.SteeringManager.SteeringManual(deltaTime, escapeVel);
-                        }
-                        else
-                        {
-                            character.AnimController.TargetDir = escapeVel.X < 0.0f ? Direction.Right : Direction.Left;
-                            character.AIController.SteeringManager.Reset();
-                        }
-                        return;
+                        Vector2 dir = character.Position - fireSource.Position;
+                        float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(fireSource.Position, character.Position), 0.1f, 10.0f);
+                        escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
                    }
                }
+                foreach (Character enemy in Character.CharacterList)
+                {
+                    if (!HumanAIController.IsActive(enemy) || HumanAIController.IsFriendly(enemy) || enemy.IsArrested) { continue; }
+                    if (HumanAIController.VisibleHulls.Contains(enemy.CurrentHull))
+                    {
+                        Vector2 dir = character.Position - enemy.Position;
+                        float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(enemy.Position, character.Position), 0.1f, 10.0f);
+                        escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
+                    }
+                }
+            }
+            if (escapeVel != Vector2.Zero)
+            {
+                float left = character.CurrentHull.Rect.X + 50;
+                float right = character.CurrentHull.Rect.Right - 50;
+                //only move if we haven't reached the edge of the room
+                if (escapeVel.X < 0 && character.Position.X > left || escapeVel.X > 0 && character.Position.X < right)
+                {
+                    character.AIController.SteeringManager.SteeringManual(deltaTime, escapeVel);
+                }
+                else
+                {
+                    character.AnimController.TargetDir = escapeVel.X < 0.0f ? Direction.Right : Direction.Left;
+                    character.AIController.SteeringManager.Reset();
+                }
+            }
+            else
+            {
                objectiveManager.GetObjective<AIObjectiveIdle>().Wander(deltaTime);
            }
        }

-        public Hull FindBestHull(IEnumerable<Hull> ignoredHulls = null, bool allowChangingTheSubmarine = true)
+        public enum HullSearchStatus
        {
-            //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)
+            Running,
+            Finished
+        }
+
+        private readonly List<Hull> hulls = new List<Hull>();
+        private int hullSearchIndex = -1;
+        float bestHullValue = 0;
+        bool bestHullIsAirlock = false;
+        Hull potentialBestHull;
+
+        /// <summary>
+        /// Tries to find the best (safe, nearby) hull the character can find a path to.
+        /// Checks one hull at a time, and returns HullSearchStatus.Finished when all potential hulls have been checked.
+        /// </summary>
+        public HullSearchStatus FindBestHull(out Hull bestHull, IEnumerable<Hull> ignoredHulls = null, bool allowChangingSubmarine = true)
+        {
+            if (hullSearchIndex == -1)
+            {
+                bestHullValue = 0;
+                potentialBestHull = null;
+                bestHullIsAirlock = false;
+                hulls.Clear();
+                var connectedSubs = character.Submarine?.GetConnectedSubs();
+                foreach (Hull hull in Hull.HullList)
+                {
+                    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 (!allowChangingSubmarine && 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; }
+                    if (connectedSubs != null && !connectedSubs.Contains(hull.Submarine)) { continue; }
+
+                    //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 hullSuitability = EstimateHullSuitability(character, hull);                  
+                    if (!hulls.Any())
+                    {
+                        hulls.Add(hull);
+                    }
+                    else
+                    {
+                        for (int i = 0; i < hulls.Count; i++)
+                        {
+                            if (hullSuitability > EstimateHullSuitability(character, hulls[i]))
+                            {
+                                hulls.Insert(i, hull);
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (hulls.None())
+                {
+                    bestHull = null;
+                    return HullSearchStatus.Finished;
+                }
+                hullSearchIndex = 0;
+            }
+
+            static float EstimateHullSuitability(Character character, Hull hull)
            {
                float dist =
                    Math.Abs(hull.WorldPosition.X - character.WorldPosition.X) +
@@ -314,86 +387,91 @@ namespace Barotrauma
                return suitability;
            }

-            Hull bestHull = null;
-            float bestValue = 0;
-            bool bestIsAirlock = false;
-            foreach (Hull hull in Hull.HullList.OrderByDescending(h => EstimateHullSuitability(h)))
+            Hull potentialHull = hulls[hullSearchIndex];
+
+            float hullSafety = 0;
+            bool hullIsAirlock = false;
+            bool isCharacterInside = character.CurrentHull != null && character.Submarine != null;
+            if (isCharacterInside)
            {
-                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;
-                bool hullIsAirlock = false;
-                bool isCharacterInside = character.CurrentHull != null && character.Submarine != null;
-                if (isCharacterInside)
-                {
-                    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);
-                    yDist = yDist > 100 ? yDist * 3 : 0;
-                    float dist = Math.Abs(character.WorldPosition.X - hull.WorldPosition.X) + yDist;
-                    float distanceFactor = MathHelper.Lerp(1, 0.9f, MathUtils.InverseLerp(0, 10000, dist));
-                    hullSafety *= distanceFactor;
-                    //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; }
+                hullSafety = HumanAIController.GetHullSafety(potentialHull, potentialHull.GetConnectedHulls(true, 1), character);
+                float yDist = Math.Abs(character.WorldPosition.Y - potentialHull.WorldPosition.Y);
+                yDist = yDist > 100 ? yDist * 3 : 0;
+                float dist = Math.Abs(character.WorldPosition.X - potentialHull.WorldPosition.X) + yDist;
+                float distanceFactor = MathHelper.Lerp(1, 0.9f, MathUtils.InverseLerp(0, 10000, dist));
+                hullSafety *= distanceFactor;
+                //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 > bestHullValue) 
+                { 
                    //avoid airlock modules if not allowed to change the sub
-                    if (!allowChangingTheSubmarine && hull.OutpostModuleTags.Any(t => t == "airlock"))
+                    if (allowChangingSubmarine || !potentialHull.OutpostModuleTags.Any(t => t == "airlock"))
                    {
-                        continue;
+                        // Don't allow to go outside if not already outside.
+                        var path = PathSteering.PathFinder.FindPath(character.SimPosition, potentialHull.SimPosition, character.Submarine, nodeFilter: node => node.Waypoint.CurrentHull != null);
+                        if (path.Unreachable)
+                        {
+                            hullSafety = 0;
+                            HumanAIController.UnreachableHulls.Add(potentialHull);
+                        }
+                        else
+                        {
+                            // Each unsafe node reduces the hull safety value.
+                            // Ignore the current hull, because otherwise we couldn't find a path out.
+                            int unsafeNodes = path.Nodes.Count(n => n.CurrentHull != character.CurrentHull && HumanAIController.UnsafeHulls.Contains(n.CurrentHull));
+                            hullSafety /= 1 + unsafeNodes;
+                            // If the target is not inside a friendly submarine, considerably reduce the hull safety.
+                            if (!character.Submarine.IsEntityFoundOnThisSub(potentialHull, true))
+                            {
+                                hullSafety /= 10;
+                            }
+                        }
                    }
-                    // Don't allow to go outside if not already outside.
-                    var path = PathSteering.PathFinder.FindPath(character.SimPosition, hull.SimPosition, character.Submarine, nodeFilter: node => node.Waypoint.CurrentHull != null);
-                    if (path.Unreachable)
+                    else
                    {
-                        HumanAIController.UnreachableHulls.Add(hull);
-                        continue;
+                        hullSafety = 0;
                    }
-                    // Each unsafe node reduces the hull safety value.
-                    // Ignore the current hull, because otherwise we couldn't find a path out.
-                    int unsafeNodes = path.Nodes.Count(n => n.CurrentHull != character.CurrentHull && HumanAIController.UnsafeHulls.Contains(n.CurrentHull));
-                    hullSafety /= 1 + unsafeNodes;
-                    // If the target is not inside a friendly submarine, considerably reduce the hull safety.
-                    if (!character.Submarine.IsEntityFoundOnThisSub(hull, true))
-                    {
-                        hullSafety /= 10;
-                    }
-                }
-                else
-                {
-                    // TODO: could also target gaps that get us inside?
-                    if (hull.IsTaggedAirlock())
-                    {
-                        hullSafety = 100;
-                        hullIsAirlock = true;
-                    }
-                    else if(!bestIsAirlock && hull.LeadsOutside(character))
-                    {
-                        hullSafety = 100;
-                    }
-                    // 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));
-                    hullSafety *= distanceFactor;
-                    // If the target is not inside a friendly submarine, considerably reduce the hull safety.
-                    // Intentionally exclude wrecks from this check
-                    if (hull.Submarine.TeamID != character.TeamID && hull.Submarine.TeamID != CharacterTeamType.FriendlyNPC)
-                    {
-                        hullSafety /= 10;
-                    }
-                }
-                if (hullSafety > bestValue || (!isCharacterInside && hullIsAirlock && !bestIsAirlock))
-                {
-                    bestHull = hull;
-                    bestValue = hullSafety;
-                    bestIsAirlock = hullIsAirlock;
                }
            }
-            return bestHull;
+            else
+            {
+                // TODO: could also target gaps that get us inside?
+                if (potentialHull.IsTaggedAirlock())
+                {
+                    hullSafety = 100;
+                    hullIsAirlock = true;
+                }
+                else if(!bestHullIsAirlock && potentialHull.LeadsOutside(character))
+                {
+                    hullSafety = 100;
+                }
+                // Huge preference for closer targets
+                float distance = Vector2.DistanceSquared(character.WorldPosition, potentialHull.WorldPosition);
+                float distanceFactor = MathHelper.Lerp(1, 0.2f, MathUtils.InverseLerp(0, MathUtils.Pow(100000, 2), distance));
+                hullSafety *= distanceFactor;
+                // If the target is not inside a friendly submarine, considerably reduce the hull safety.
+                // Intentionally exclude wrecks from this check
+                if (potentialHull.Submarine.TeamID != character.TeamID && potentialHull.Submarine.TeamID != CharacterTeamType.FriendlyNPC)
+                {
+                    hullSafety /= 10;
+                }
+            }
+            if (hullSafety > bestHullValue || (!isCharacterInside && hullIsAirlock && !bestHullIsAirlock))
+            {
+                potentialBestHull = potentialHull;
+                bestHullValue = hullSafety;
+                bestHullIsAirlock = hullIsAirlock;
+            }
+
+            bestHull = potentialBestHull;
+            hullSearchIndex++;
+
+            if (hullSearchIndex >= hulls.Count)
+            {
+                hullSearchIndex = -1;
+                return HullSearchStatus.Finished;
+            }
+            return HullSearchStatus.Running;
        }

        public override void Reset()
@@ -48,16 +48,29 @@ namespace Barotrauma
            }
            else
            {
-                float xDist = Math.Abs(character.WorldPosition.X - Leak.WorldPosition.X);
-                float yDist = Math.Abs(character.WorldPosition.Y - Leak.WorldPosition.Y);
-                // Vertical distance matters more than horizontal (climbing up/down is harder than moving horizontally).
-                // If the target is close, ignore the distance factor alltogether so that we keep fixing the leaks that are nearby.
-                float distanceFactor = isPriority || xDist < 200 && yDist < 100 ? 1 : MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 3000, xDist + yDist * 3.0f));
-                float severity = isPriority ? 1 : AIObjectiveFixLeaks.GetLeakSeverity(Leak) / 100;
                float reduction = isPriority ? 1 : 2;
-                float max = AIObjectiveManager.LowestOrderPriority - reduction;
-                float devotion = CumulatedDevotion / 100;
-                Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (severity * distanceFactor * PriorityModifier), 0, 1));
+                float maxPriority = AIObjectiveManager.LowestOrderPriority - reduction;
+                if (operateObjective != null && objectiveManager.GetActiveObjective<AIObjectiveFixLeaks>() is AIObjectiveFixLeaks fixLeaks && fixLeaks.CurrentSubObjective == this)
+                {
+                    // Prioritize leaks that we are already fixing
+                    Priority = maxPriority;
+                }
+                else
+                {
+                    float xDist = Math.Abs(character.WorldPosition.X - Leak.WorldPosition.X);
+                    float yDist = Math.Abs(character.WorldPosition.Y - Leak.WorldPosition.Y);
+                    // Vertical distance matters more than horizontal (climbing up/down is harder than moving horizontally).
+                    // If the target is close, ignore the distance factor alltogether so that we keep fixing the leaks that are nearby.
+                    float distanceFactor = isPriority || xDist < 200 && yDist < 100 ? 1 : MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 3000, xDist + yDist * 3.0f));
+                    if (Leak.linkedTo.Any(e => e is Hull h && h == character.CurrentHull))
+                    {
+                        // Double the distance when the leak can be accessed from the current hull.
+                        distanceFactor *= 2;
+                    }
+                    float severity = isPriority ? 1 : AIObjectiveFixLeaks.GetLeakSeverity(Leak) / 100;
+                    float devotion = CumulatedDevotion / 100;
+                    Priority = MathHelper.Lerp(0, maxPriority, MathHelper.Clamp(devotion + (severity * distanceFactor * PriorityModifier), 0, 1));
+                }
            }
            return Priority;
        }
@@ -165,6 +178,7 @@ namespace Barotrauma
                    requiredCondition = () => 
                        Leak.Submarine == character.Submarine &&
                        Leak.linkedTo.Any(e => e is Hull h && character.CurrentHull == h),
+                    endNodeFilter = n => n.Waypoint.CurrentHull != null && Leak.linkedTo.Any(e => e is Hull h && h == n.Waypoint.CurrentHull),
                    // The Go To objective can be abandoned if the leak is fixed (in which case we don't want to use the dialogue)
                    SpeakCannotReachCondition = () => !CheckObjectiveSpecific()
                },
@@ -201,7 +215,7 @@ namespace Barotrauma
            // This is an approximation, because we don't know the exact reach until the pose is taken.
            // And even then the actual range depends on the direction we are aiming to.
            // Found out that without any multiplier the value (209) is often too short.
-            return repairTool.Range + armLength * 1.3f;
+            return repairTool.Range + armLength * 2;
        }
    }
 }
@@ -471,7 +471,8 @@ namespace Barotrauma
                {
                    if (spawnItemIfNotFound)
                    {
-                        if (!(MapEntityPrefab.List.FirstOrDefault(me => me is ItemPrefab ip && IdentifiersOrTags.Any(id => id == ip.Identifier || ip.Tags.Contains(id))) is ItemPrefab prefab))
+                        ItemPrefab prefab = FindItemToSpawn();
+                        if (prefab == null)
                        {
 #if DEBUG
                            DebugConsole.NewMessage($"{character.Name}: Cannot find an item with the following identifier(s) or tag(s): {string.Join(", ", IdentifiersOrTags)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
@@ -501,6 +502,33 @@ namespace Barotrauma
            }
        }

+        /// <summary>
+        /// Returns the "best" item to spawn when using <see cref="spawnItemIfNotFound"/> and there's multiple suitable items.
+        /// Best in this context is the one that's sold at the lowest price in stores (usually the most "basic" item)
+        /// </summary>
+        /// <returns></returns>
+        private ItemPrefab FindItemToSpawn()
+        {
+            ItemPrefab bestItem = null;
+            float lowestCost = float.MaxValue;
+            foreach (MapEntityPrefab prefab in MapEntityPrefab.List)
+            {
+                if (!(prefab is ItemPrefab itemPrefab)) { continue; }
+                if (IdentifiersOrTags.Any(id => id == prefab.Identifier || prefab.Tags.Contains(id)))
+                {
+                    float cost = itemPrefab.DefaultPrice != null && itemPrefab.CanBeBought ?
+                        itemPrefab.DefaultPrice.Price :
+                        float.MaxValue;
+                    if (cost < lowestCost || bestItem == null)
+                    {
+                        bestItem = itemPrefab;
+                        lowestCost = cost;
+                    }
+                }
+            }
+            return bestItem;
+        }
+
        protected override bool CheckObjectiveSpecific()
        {
            if (IsCompleted) { return true; }
@@ -185,6 +185,11 @@ namespace Barotrauma
                {
                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(currentTarget), weight: 1, nodeFilter: node => node.Waypoint.CurrentHull != null);
                }
+                else
+                {
+                    PathSteering.ResetPath();
+                    PathSteering.Reset();
+                }
            }
            else
            {
@@ -290,12 +295,25 @@ namespace Barotrauma
                {
                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(currentTarget), weight: 1, nodeFilter: node => node.Waypoint.CurrentHull != null);
                }
+                else
+                {
+                    PathSteering.ResetPath();
+                    PathSteering.Reset();
+                }
            }
        }

        public void Wander(float deltaTime)
        {
-            if (character.IsClimbing) { return; }
+            if (character.IsClimbing)
+            {
+                if (character.AnimController.GetHeightFromFloor() < 0.1f)
+                {
+                    character.AnimController.Anim = AnimController.Animation.None;
+                    character.SelectedConstruction = null;
+                }
+                return;
+            }
            var currentHull = character.CurrentHull;
            if (!character.AnimController.InWater && currentHull != null)
            {
@@ -470,7 +488,7 @@ namespace Barotrauma
                if (hull != null)
                {
                    itemsToClean.Clear();
-                    foreach (Item item in Item.ItemList)
+                    foreach (Item item in Item.CleanableItems)
                    {
                        if (item.CurrentHull != hull) { continue; }
                        if (AIObjectiveCleanupItems.IsValidTarget(item, character, checkInventory: true, allowUnloading: false) && !ignoredItems.Contains(item))
@@ -39,12 +39,21 @@ namespace Barotrauma
            {
                TargetContainers.Add(targetContainer);
            }
+            else
+            {
+                foreach (Item item in Item.ItemList)
+                {
+                    if (!OrderPrefab.TargetItemsMatchItem(TargetContainerTags, item)) { continue; }
+                    TargetContainers.Add(item);
+                }
+            }
            TargetCondition = option == "turretammo" ? ItemCondition.Empty : ItemCondition.Full;
        }

        protected override bool Filter(Item target)
        {
-            if (!IsValidTarget(target, character, TargetContainerTags, TargetCondition)) { return false; }
+            //don't pass TargetContainerTags to the method (no need to filter by tags anymore, it's already done when populating TargetContainers)
+            if (!IsValidTarget(target, character, null, TargetCondition)) { return false; }
            if (target.CurrentHull == null || target.CurrentHull.FireSources.Count > 0) { return false; }
            if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))) { return false; }
            return true;
@@ -52,8 +61,7 @@ namespace Barotrauma

        public static bool IsValidTarget(Item item, Character character, ImmutableArray<Identifier>? targetContainerTags = null, ItemCondition? targetCondition = null)
        {
-            if (item == null) { return false; }
-            if (item.Removed) { return false; }
+            if (item == null || item.Removed) { return false; }
            if (targetContainerTags.HasValue && !OrderPrefab.TargetItemsMatchItem(targetContainerTags.Value, item)) { return false; }
            if (!(item.GetComponent<ItemContainer>() is ItemContainer container)) { return false; }
            if (container.Inventory == null) { return false; }
@@ -88,7 +96,7 @@ namespace Barotrauma
            }
        }

-        protected override IEnumerable<Item> GetList() => TargetContainers.Any() ? TargetContainers : Item.ItemList;
+        protected override IEnumerable<Item> GetList() => TargetContainers;

        protected override AIObjective ObjectiveConstructor(Item target)
            => new AIObjectiveLoadItem(target, TargetContainerTags, TargetCondition, Option, character, objectiveManager, PriorityModifier);
@@ -151,7 +151,7 @@ namespace Barotrauma
                }
                var order = new Order(orderPrefab, autonomousObjective.Option, item ?? character.CurrentHull as Entity, orderPrefab.GetTargetItemComponent(item), orderGiver: character);
                if (order == null) { continue; }
-                if ((order.IgnoreAtOutpost || autonomousObjective.IgnoreAtOutpost) && Level.IsLoadedOutpost && character.TeamID != CharacterTeamType.FriendlyNPC)
+                if ((order.IgnoreAtOutpost || autonomousObjective.IgnoreAtOutpost) && Level.IsLoadedFriendlyOutpost && character.TeamID != CharacterTeamType.FriendlyNPC)
                {
                    if (Submarine.MainSub != null && Submarine.MainSub.DockedTo.None(s => s.TeamID != CharacterTeamType.FriendlyNPC && s.TeamID != character.TeamID))
                    {
@@ -13,7 +13,7 @@ namespace Barotrauma
        public override bool KeepDivingGearOn => true;
        public override bool AllowAutomaticItemUnequipping => true;

-        private IEnumerable<Pump> pumpList;
+        private List<Pump> pumpList;

        public AIObjectivePumpWater(Character character, AIObjectiveManager objectiveManager, Identifier option, float priorityModifier = 1)
            : base(character, objectiveManager, priorityModifier, option) { }
@@ -26,13 +26,9 @@ namespace Barotrauma

        protected override bool Filter(Pump pump)
        {
-            if (pump == null) { return false; }
+            if (pump?.Item == null || pump.Item.Removed) { return false; }
            if (pump.Item.IgnoreByAI(character)) { return false; }
            if (!pump.Item.IsInteractable(character)) { return false; }
-            if (pump.Item.HasTag("ballast")) { return false; }
-            if (pump.Item.Submarine == null) { return false; }
-            if (pump.Item.CurrentHull == null) { return false; }
-            if (pump.Item.Submarine.TeamID != character.TeamID) { return false; }
            if (pump.IsAutoControlled) { return false; }
            if (pump.Item.ConditionPercentage <= 0) { return false; }
            if (pump.Item.CurrentHull.FireSources.Count > 0) { return false; }
@@ -50,7 +46,16 @@ namespace Barotrauma
            if (pumpList == null)
            {
                if (character == null || character.Submarine == null) { return Array.Empty<Pump>(); }
-                pumpList = character.Submarine.GetItems(true).Select(i => i.GetComponent<Pump>()).Where(p => p != null);
+
+                pumpList = new List<Pump>();
+                foreach (Item item in character.Submarine.GetItems(true))
+                {
+                    var pump = item.GetComponent<Pump>();
+                    if (pump == null || pump.Item.Submarine == null || pump.Item.CurrentHull == null) { continue; }
+                    if (pump.Item.Submarine.TeamID != character.TeamID) { continue; }
+                    if (pump.Item.HasTag("ballast")) { continue; }
+                    pumpList.Add(pump);
+                }
            }
            return pumpList;
        }
@@ -238,7 +238,7 @@ namespace Barotrauma
                        };
                        if (repairTool != null)
                        {
-                            objective.CloseEnough = repairTool.Range * 0.75f;
+                            objective.CloseEnough = AIObjectiveFixLeak.CalculateReach(repairTool, character);
                        }
                        return objective;
                    },                    
@@ -136,7 +136,7 @@ namespace Barotrauma
            return MathHelper.Lerp(0, 100, MathHelper.Clamp(damagePriority * successFactor, 0, 1));
        }

-        protected override IEnumerable<Item> GetList() => Item.ItemList;
+        protected override IEnumerable<Item> GetList() => Item.RepairableItems;

        protected override AIObjective ObjectiveConstructor(Item item) 
            => new AIObjectiveRepairItem(character, item, objectiveManager, priorityModifier: PriorityModifier, isPriority: item == PrioritizedItem);
@@ -156,6 +156,9 @@ namespace Barotrauma
            if (character.IsOnPlayerTeam && item.Submarine.Info.IsOutpost) { return false; }
            if (!character.Submarine.IsEntityFoundOnThisSub(item, includingConnectedSubs: true)) { return false; }
            if (item.Repairables.None()) { return false; }
+
+            System.Diagnostics.Debug.Assert(item.Repairables.Any(), "Invalid target in AIObjectiveRepairItems - the objective should only be checking items that have a Repairable component (Item.RepairableItems)");
+
            return true;
        }
    }
@@ -4,6 +4,7 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using static Barotrauma.AIObjectiveFindSafety;

 namespace Barotrauma
 {
@@ -186,7 +187,9 @@ namespace Barotrauma
                                    }
                                    else
                                    {
-                                        safeHull = objectiveManager.GetObjective<AIObjectiveFindSafety>().FindBestHull(HumanAIController.VisibleHulls);
+                                        HullSearchStatus hullSearchStatus = objectiveManager.GetObjective<AIObjectiveFindSafety>().FindBestHull(out Hull potentialSafeHull, HumanAIController.VisibleHulls);
+                                        if (hullSearchStatus != HullSearchStatus.Finished) { return; }
+                                        safeHull = potentialSafeHull;
                                        findHullTimer = findHullInterval * Rand.Range(0.9f, 1.1f);
                                    }
                                }