Unstable v0.1100.0.4 (November 11th 2020)

2020-11-06 20:12:15 +02:00
parent 6b36bf809d
commit b772654326
297 changed files with 12502 additions and 4277 deletions
@@ -91,9 +91,12 @@ namespace Barotrauma

        private float avoidTimer;
        private float observeTimer;
+        private float sweepTimer;

        public bool StayInsideLevel = true;

+        private readonly IEnumerable<Body> myBodies;
+
        public LatchOntoAI LatchOntoAI { get; private set; }
        public SwarmBehavior SwarmBehavior { get; private set; }
        public PetBehavior PetBehavior { get; private set; }
@@ -223,6 +226,7 @@ namespace Barotrauma
            requiredHoleCount = (int)Math.Ceiling(ConvertUnits.ToDisplayUnits(colliderWidth) / Structure.WallSectionSize);

            avoidLookAheadDistance = Math.Max(colliderWidth * 3, 1.5f);
+            myBodies = Character.AnimController.Limbs.Select(l => l.body.FarseerBody);
        }

        public CharacterParams.AIParams AIParams => Character.Params.AI;
@@ -434,7 +438,7 @@ namespace Barotrauma
                    UpdateIdle(deltaTime);
                    break;
                case AIState.Attack:
-                    run = !IsCoolDownRunning;
+                    run = !IsCoolDownRunning || AttackingLimb != null && AttackingLimb.attack.FullSpeedAfterAttack;
                    UpdateAttack(deltaTime);
                    break;
                case AIState.Eat:
@@ -471,7 +475,7 @@ namespace Barotrauma
                    {
                        bool isBeingChased = IsBeingChased;
                        float reactDistance = !isBeingChased && selectedTargetingParams != null && selectedTargetingParams.ReactDistance > 0 ? selectedTargetingParams.ReactDistance : GetPerceivingRange(SelectedAiTarget);
-                        if (squaredDistance <= Math.Pow(reactDistance + movementMargin, 2))
+                        if (squaredDistance <= Math.Pow(reactDistance, 2))
                        {
                            float halfReactDistance = reactDistance / 2;
                            float attackDistance = selectedTargetingParams != null && selectedTargetingParams.AttackDistance > 0 ? selectedTargetingParams.AttackDistance : halfReactDistance;
@@ -483,17 +487,12 @@ namespace Barotrauma
                            else
                            {
                                run = isBeingChased ? true : squaredDistance < Math.Pow(halfReactDistance, 2);
-                                if (movementMargin <= 0)
-                                {
-                                    movementMargin = halfReactDistance;
-                                }
-                                movementMargin = MathHelper.Clamp(movementMargin += deltaTime, halfReactDistance, reactDistance);
-                                UpdateEscape(deltaTime);
+                                State = AIState.Escape;
+                                avoidTimer = AIParams.AvoidTime * 0.5f * Rand.Range(0.75f, 1.25f);
                            }
                        }
                        else
                        {
-                            movementMargin = 0;
                            UpdateIdle(deltaTime);
                        }
                    }
@@ -617,7 +616,7 @@ namespace Barotrauma

        #region Idle

-        private void UpdateIdle(float deltaTime)
+        private void UpdateIdle(float deltaTime, bool followLastTarget = true)
        {
            var pathSteering = SteeringManager as IndoorsSteeringManager;
            if (pathSteering == null)
@@ -630,32 +629,35 @@ namespace Barotrauma
                    return;
                }
            }
-            var target = SelectedAiTarget ?? _lastAiTarget;
-            if (target?.Entity != null && !target.Entity.Removed && PreviousState == AIState.Attack && Character.CurrentHull == null)
+            if (followLastTarget)
            {
-                // Keep heading to the last known position of the target
-                var memory = GetTargetMemory(target, false);
-                if (memory != null)
+                var target = SelectedAiTarget ?? _lastAiTarget;
+                if (target?.Entity != null && !target.Entity.Removed && PreviousState == AIState.Attack && Character.CurrentHull == null)
                {
-                    var location = memory.Location;
-                    float dist = Vector2.DistanceSquared(WorldPosition, location);
-                    if (dist < 50 * 50)
+                    // Keep heading to the last known position of the target
+                    var memory = GetTargetMemory(target, false);
+                    if (memory != null)
                    {
-                        // Target is gone
-                        ResetAITarget();
+                        var location = memory.Location;
+                        float dist = Vector2.DistanceSquared(WorldPosition, location);
+                        if (dist < 50 * 50)
+                        {
+                            // Target is gone
+                            ResetAITarget();
+                        }
+                        else
+                        {
+                            // Steer towards the target
+                            SteeringManager.SteeringSeek(Character.GetRelativeSimPosition(target.Entity, location), 5);
+                            SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 15);
+                            return;
+                        }
                    }
                    else
                    {
-                        // Steer towards the target
-                        SteeringManager.SteeringSeek(Character.GetRelativeSimPosition(target.Entity, location), 5);
-                        SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 15);
-                        return;
+                        ResetAITarget();
                    }
                }
-                else
-                {
-                    ResetAITarget();
-                }
            }
            if (pathSteering != null && !Character.AnimController.InWater)
            {
@@ -686,7 +688,7 @@ namespace Barotrauma
                State = AIState.Idle;
                return;
            }
-            else if (selectedTargetMemory != null)
+            else if (selectedTargetMemory != null && SelectedAiTarget?.Entity is Character)
            {
                selectedTargetMemory.Priority += deltaTime * priorityFearIncreasement;
            }
@@ -880,7 +882,7 @@ namespace Barotrauma
                        {
                            if (door.LinkedGap.Size > ConvertUnits.ToDisplayUnits(colliderWidth))
                            {
-                                LatchOntoAI?.DeattachFromBody(cooldown: 2);
+                                LatchOntoAI?.DeattachFromBody(reset: true, cooldown: 2);
                                Character.AnimController.ReleaseStuckLimbs();
                                var velocity = Vector2.Normalize(door.LinkedGap.FlowTargetHull.WorldPosition - Character.WorldPosition);
                                steeringManager.SteeringManual(deltaTime, velocity);
@@ -1040,6 +1042,48 @@ namespace Barotrauma
                            }
                        }
                        break;
+                    case AIBehaviorAfterAttack.IdleUntilCanAttack:
+                        if (AttackingLimb.attack.SecondaryCoolDown <= 0)
+                        {
+                            // No (valid) secondary cooldown defined.
+                            UpdateIdle(deltaTime, followLastTarget: false);
+                            return;
+                        }
+                        else
+                        {
+                            if (AttackingLimb.attack.SecondaryCoolDownTimer <= 0)
+                            {
+                                // Don't allow attacking when the attack target has just changed.
+                                if (_previousAiTarget != null && SelectedAiTarget != _previousAiTarget)
+                                {
+                                    UpdateIdle(deltaTime, followLastTarget: false);
+                                    return;
+                                }
+                                else
+                                {
+                                    // If the secondary cooldown is defined and expired, check if we can switch the attack
+                                    var newLimb = GetAttackLimb(attackWorldPos, AttackingLimb);
+                                    if (newLimb != null)
+                                    {
+                                        // Attack with the new limb
+                                        AttackingLimb = newLimb;
+                                    }
+                                    else
+                                    {
+                                        // No new limb was found.
+                                        UpdateIdle(deltaTime, followLastTarget: false);
+                                        return;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                // Cooldown not yet expired
+                                UpdateIdle(deltaTime, followLastTarget: false);
+                                return;
+                            }
+                        }
+                        break;
                    case AIBehaviorAfterAttack.FollowThrough:
                        UpdateFallBack(attackWorldPos, deltaTime, followThrough: true);
                        return;
@@ -1145,7 +1189,56 @@ namespace Barotrauma
                // Check that we can reach the target
                distance = toTarget.Length();
                canAttack = distance < AttackingLimb.attack.Range;
-                if (!canAttack && !IsCoolDownRunning)
+                if (canAttack)
+                {
+                    if (AttackingLimb.attack.Ranged)
+                    {
+                        // Check that is facing the target
+                        float offset = AttackingLimb.Params.GetSpriteOrientation() - MathHelper.PiOver2;
+                        Vector2 forward = VectorExtensions.Forward(AttackingLimb.body.TransformedRotation - offset * Character.AnimController.Dir);
+                        float angle = VectorExtensions.Angle(forward, toTarget);
+                        canAttack = angle < MathHelper.ToRadians(AttackingLimb.attack.RequiredAngle);
+                        if (canAttack && AttackingLimb.attack.AvoidFriendlyFire)
+                        {
+                            float minDistance = MathUtils.Pow(ConvertUnits.ToDisplayUnits(Character.AnimController.Collider.GetMaxExtent() * 3), 2);
+                            bool IsFarEnough(Character other) => Vector2.DistanceSquared(Character.WorldPosition, other.WorldPosition) > minDistance;
+                            if (SwarmBehavior != null)
+                            {
+                                canAttack = SwarmBehavior.Members.All(c => c == Character || IsFarEnough(c));
+                            }
+                            else
+                            {
+                                canAttack = Character.CharacterList.All(c => c == Character || !IsFriendly(Character, c) || IsFarEnough(c));
+                            }
+                            if (canAttack)
+                            {
+                                canAttack = !IsBlocked(attackSimPos) && !IsBlocked(AttackingLimb.SimPosition + forward * ConvertUnits.ToSimUnits(AttackingLimb.attack.Range));
+
+                                bool IsBlocked(Vector2 targetPosition)
+                                {
+                                    foreach (var body in Submarine.PickBodies(AttackingLimb.SimPosition, targetPosition, myBodies, Physics.CollisionCharacter))
+                                    {
+                                        Character hitTarget = null;
+                                        if (body.UserData is Character c)
+                                        {
+                                            hitTarget = c;
+                                        }
+                                        else if (body.UserData is Limb limb)
+                                        {
+                                            hitTarget = limb.character;
+                                        }
+                                        if (hitTarget != null && !hitTarget.IsDead && IsFriendly(Character, hitTarget))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (!IsCoolDownRunning)
                {
                    // If not, reset the attacking limb, if the cooldown is not running
                    // Don't use the property, because we don't want cancel reversing, if we are reversing.
@@ -1160,29 +1253,11 @@ namespace Barotrauma
                    }
                }
            }
-            Limb steeringLimb = canAttack ? AttackingLimb : null;
+            Limb steeringLimb = canAttack && !AttackingLimb.attack.Ranged ? AttackingLimb : null;
            if (steeringLimb == null)
            {
-                // If the attacking limb is a hand or claw, for example, using it as the steering limb can end in the result where the character circles around the target. For example the Hammerhead steering with the claws when it should use the torso.
-                // If we always use the main limb, this causes the character to seek the target with it's torso/head, when it should not. For example Mudraptor steering with it's belly, when it should use it's head.
-                // So let's use the one that's closer to the attacking limb.
-                var torso = Character.AnimController.GetLimb(LimbType.Torso);
-                var head = Character.AnimController.GetLimb(LimbType.Head);
-                if (AttackingLimb == null)
-                {
-                    steeringLimb = head ?? torso;
-                }
-                else
-                {
-                    if (head != null && torso != null)
-                    {
-                        steeringLimb = Vector2.DistanceSquared(AttackingLimb.SimPosition, head.SimPosition) < Vector2.DistanceSquared(AttackingLimb.SimPosition, torso.SimPosition) ? head : torso;
-                    }
-                    else
-                    {
-                        steeringLimb = head ?? torso;
-                    }
-                }
+                // If the attacking limb is a hand or claw, for example, using it as the steering limb can end in the result where the character circles around the target.
+                steeringLimb = Character.AnimController.GetLimb(LimbType.Head) ?? Character.AnimController.GetLimb(LimbType.Torso);
            }

            if (steeringLimb == null)
@@ -1190,7 +1265,7 @@ namespace Barotrauma
                State = AIState.Idle;
                return;
            }
-
+            
            if (AttackingLimb != null && AttackingLimb.attack.Retreat)
            {
                UpdateFallBack(attackWorldPos, deltaTime, false);
@@ -1250,6 +1325,25 @@ namespace Barotrauma
                }
                else
                {
+                    if (selectedTargetingParams.SweepDistance > 0)
+                    {
+                        Vector2 toTarget = attackWorldPos - WorldPosition;
+                        if (distance <= 0)
+                        {
+                            distance = toTarget.Length();
+                        }
+                        float amplitude = MathHelper.Lerp(0, selectedTargetingParams.SweepStrength, MathUtils.InverseLerp(selectedTargetingParams.SweepDistance, 0, distance));
+                        if (amplitude > 0)
+                        {
+                            sweepTimer += deltaTime * selectedTargetingParams.SweepSpeed;
+                            float sin = (float)Math.Sin(sweepTimer) * amplitude;
+                            steerPos = MathUtils.RotatePointAroundTarget(attackSimPos, SimPosition, MathHelper.ToDegrees(sin));
+                        }
+                        else
+                        {
+                            sweepTimer = Rand.Range(-1000, 1000) * selectedTargetingParams.SweepSpeed;
+                        }
+                    }
                    SteeringManager.SteeringSeek(steerPos, 10);
                    SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 15);
                }
@@ -1268,7 +1362,7 @@ namespace Barotrauma
        {
            IsSteeringThroughGap = true;
            wallTarget = null;
-            LatchOntoAI?.DeattachFromBody(cooldown: 2);
+            LatchOntoAI?.DeattachFromBody(reset: true, cooldown: 2);
            Character.AnimController.ReleaseStuckLimbs();
            Hull targetHull = section.gap?.FlowTargetHull;
            float maxDistance = Math.Min(wall.Rect.Width, wall.Rect.Height);
@@ -1308,6 +1402,7 @@ namespace Barotrauma
            {
                if (limb == ignoredLimb) { continue; }
                if (limb.IsSevered || limb.IsStuck) { continue; }
+                if (limb.Disabled) { continue; }
                var attack = limb.attack;
                if (attack == null) { continue; }
                if (attack.CoolDownTimer > 0) { continue; }
@@ -1318,6 +1413,17 @@ namespace Barotrauma
                    if (attack.Conditionals.Any(c => !c.Matches(se))) { continue; }
                }
                if (attack.Conditionals.Any(c => c.TargetSelf && !c.Matches(Character))) { continue; }
+                if (attack.Ranged)
+                {
+                    // Check that is approximately facing the target
+                    Vector2 attackLimbPos = Character.AnimController.SimplePhysicsEnabled ? Character.WorldPosition : limb.WorldPosition;
+                    Vector2 toTarget = attackWorldPos - attackLimbPos;
+                    float offset = limb.Params.GetSpriteOrientation() - MathHelper.PiOver2;
+                    Vector2 forward = VectorExtensions.Forward(limb.body.TransformedRotation - offset * Character.AnimController.Dir);
+                    float angle = VectorExtensions.Angle(forward, toTarget);
+                    if (angle > MathHelper.ToRadians(attack.RequiredAngle)) { continue; }
+                }
+
                if (AIParams.RandomAttack)
                {
                    attackLimbs.Add(limb);
@@ -1407,7 +1513,7 @@ namespace Barotrauma
                        attachTargetNormal = new Vector2(Math.Sign(WorldPosition.X - wall.WorldPosition.X), 0.0f);
                        sectionPos.X += (wall.BodyWidth <= 0.0f ? wall.Rect.Width : wall.BodyWidth) / 2 * attachTargetNormal.X;
                    }
-                    LatchOntoAI?.SetAttachTarget(wall.Submarine.PhysicsBody.FarseerBody, wall.Submarine, ConvertUnits.ToSimUnits(sectionPos), attachTargetNormal);
+                    LatchOntoAI?.SetAttachTarget(wall, ConvertUnits.ToSimUnits(sectionPos), attachTargetNormal);
                    if (Character.AnimController.CanEnterSubmarine || !wall.SectionBodyDisabled(sectionIndex) && !IsWallDisabled(wall))
                    {
                        if (AIParams.TargetOuterWalls || wall.prefab.Tags.Contains("inner") || wall.Submarine != null && wall.Submarine == Character.Submarine)
@@ -1450,13 +1556,13 @@ namespace Barotrauma

            bool wasLatched = IsLatchedOnSub;
            Character.AnimController.ReleaseStuckLimbs();
-            LatchOntoAI?.DeattachFromBody(cooldown: 1);
+            LatchOntoAI?.DeattachFromBody(reset: true, cooldown: 1);
            if (attacker == null || attacker.AiTarget == null || attacker.Removed || attacker.IsDead) { return; }
            bool isFriendly = IsFriendly(Character, attacker);
            if (wasLatched)
            {
                State = AIState.Escape;
-                avoidTimer = AIParams.AvoidTime * Rand.Range(0.75f, 1.25f);
+                avoidTimer = AIParams.AvoidTime * 0.5f * Rand.Range(0.75f, 1.25f);
                if (!isFriendly)
                {
                    SelectTarget(attacker.AiTarget);
@@ -1664,14 +1770,15 @@ namespace Barotrauma
                                item.body.LinearVelocity *= 0.9f;
                                item.body.LinearVelocity -= limbDiff * 0.25f;

+                                bool wasBroken = item.Condition <= 0.0f;
+
                                item.AddDamage(Character, item.WorldPosition, new Attack(0.0f, 0.0f, 0.0f, 0.0f, 0.1f), deltaTime);

                                if (item.Condition <= 0.0f)
                                {
+                                    if (!wasBroken) { PetBehavior?.OnEat(item.GetTags(), 1.0f); }
                                    Entity.Spawner.AddToRemoveQueue(item);
                                }
-
-                                PetBehavior?.OnEat(item.GetTags(), 0.1f / item.MaxCondition);
                            }
                        }
                    }
@@ -2028,6 +2135,8 @@ namespace Barotrauma
                if (targetingTag == null) { continue; }
                var targetParams = GetTargetParams(targetingTag);
                if (targetParams == null) { continue; }
+                if (targetParams.IgnoreWhileInside && character.CurrentHull != null) { continue; }
+                if (targetParams.IgnoreWhileOutside && character.CurrentHull == null) { continue; }
                if (targetParams.State == AIState.Observe || targetParams.State == AIState.Eat)
                {
                    if (targetCharacter != null && targetCharacter.Submarine != Character.Submarine)
@@ -2036,10 +2145,7 @@ namespace Barotrauma
                        continue;
                    }
                }
-                if (aiTarget.Entity is Item targetItem && targetParams.IgnoreContained && targetItem.ParentInventory != null)
-                {
-                    continue;
-                }
+                if (aiTarget.Entity is Item targetItem && targetParams.IgnoreContained && targetItem.ParentInventory != null) { continue; }
                valueModifier *= targetParams.Priority;

                if (valueModifier == 0.0f) { continue; }
@@ -2193,7 +2299,7 @@ namespace Barotrauma
                    if (releaseTarget)
                    {
                        wallTarget = null;
-                        LatchOntoAI.DeattachFromBody(cooldown: 1);
+                        LatchOntoAI.DeattachFromBody(reset: true, cooldown: 1);
                    }
                }
                else
@@ -2407,7 +2513,7 @@ namespace Barotrauma

        protected override void OnStateChanged(AIState from, AIState to)
        {
-            LatchOntoAI?.DeattachFromBody();
+            LatchOntoAI?.DeattachFromBody(reset: true);
            Character.AnimController.ReleaseStuckLimbs();
            escapeTarget = null;
            AttackingLimb = null;
@@ -2448,14 +2554,15 @@ namespace Barotrauma
            foreach (var limb in Character.AnimController.Limbs)
            {
                if (limb.IsSevered) { continue; }
+                if (limb.Disabled) { continue; }
                if (limb.attack == null) { continue; }
                if (!canAttackWalls)
                {
-                    canAttackWalls = limb.attack.IsValidTarget(AttackTarget.Structure) && limb.attack.StructureDamage > 0;
+                    canAttackWalls = limb.attack.IsValidTarget(AttackTarget.Structure) && (limb.attack.StructureDamage > 0 || limb.attack.Ranged);
                }
                if (!canAttackDoors)
                {
-                    canAttackDoors = limb.attack.IsValidTarget(AttackTarget.Structure) && limb.attack.ItemDamage > 0;
+                    canAttackDoors = limb.attack.IsValidTarget(AttackTarget.Structure) && (limb.attack.ItemDamage > 0 || limb.attack.Ranged);
                }
                if (!canAttackCharacters)
                {
@@ -2502,7 +2609,7 @@ namespace Barotrauma
            }
        }

-        private bool CanPassThroughHole(Structure wall, int sectionIndex)
+        public bool CanPassThroughHole(Structure wall, int sectionIndex)
        {
            if (!wall.SectionBodyDisabled(sectionIndex)) return false;
            int holeCount = 1;
@@ -2545,6 +2652,7 @@ namespace Barotrauma
            foreach (Limb limb in targetLimbs)
            {
                if (limb.IsSevered) { continue; }
+                if (limb.Hidden) { continue; }
                float dist = Vector2.DistanceSquared(limb.WorldPosition, attackLimb.WorldPosition) / Math.Max(limb.AttackPriority, 0.1f);
                if (dist < closestDist)
                {
@@ -38,11 +38,49 @@ namespace Barotrauma
        private float respondToAttackTimer;
        private const float RespondToAttackInterval = 1.0f;

+        private bool freezeAI;
+
+        private readonly float maxSteeringBuffer = 5000;
+        private readonly float minSteeringBuffer = 500;
+        private readonly float steeringBufferIncreaseSpeed = 100;
+        private float steeringBuffer;
+
+        private readonly float obstacleRaycastInterval = 1;
+        private float obstacleRaycastTimer;
+
        /// <summary>
        /// List of previous attacks done to this character
        /// </summary>
        private readonly Dictionary<Character, AttackResult> previousAttackResults = new Dictionary<Character, AttackResult>();

+        private readonly SteeringManager outsideSteering, insideSteering;
+
+        public IndoorsSteeringManager PathSteering => insideSteering as IndoorsSteeringManager;
+        public HumanoidAnimController AnimController => Character.AnimController as HumanoidAnimController;
+
+        public override AIObjectiveManager ObjectiveManager
+        {
+            get { return objectiveManager; }
+        }
+
+        public Order CurrentOrder
+        {
+            get;
+            private set;
+        }
+
+        public string CurrentOrderOption
+        {
+            get;
+            private set;
+        }
+
+        public float CurrentHullSafety { get; private set; } = 100;
+
+        private readonly Dictionary<Character, float> damageDoneByAttacker = new Dictionary<Character, float>();
+        private readonly HashSet<Character> attackers = new HashSet<Character>();
+
+        private readonly Dictionary<Hull, HullSafety> knownHulls = new Dictionary<Hull, HullSafety>();
        private class HullSafety
        {
            public float safety;
@@ -72,35 +110,6 @@ namespace Barotrauma
            }
        }

-        private readonly Dictionary<Hull, HullSafety> knownHulls = new Dictionary<Hull, HullSafety>();
-
-        private SteeringManager outsideSteering, insideSteering;
-
-        public IndoorsSteeringManager PathSteering => insideSteering as IndoorsSteeringManager;
-        public HumanoidAnimController AnimController => Character.AnimController as HumanoidAnimController;
-
-        public override AIObjectiveManager ObjectiveManager
-        {
-            get { return objectiveManager; }
-        }
-
-        public Order CurrentOrder
-        {
-            get;
-            private set;
-        }
-
-        public string CurrentOrderOption
-        {
-            get;
-            private set;
-        }
-
-        public float CurrentHullSafety { get; private set; } = 100;
-
-        private readonly Dictionary<Character, float> damageDoneByAttacker = new Dictionary<Character, float>();
-        private readonly HashSet<Character> attackers = new HashSet<Character>();
-
        public HumanAIController(Character c) : base(c)
        {
            if (!c.IsHuman)
@@ -117,8 +126,6 @@ namespace Barotrauma

        partial void InitProjSpecific();

-        private bool freezeAI;
-
        public override void Update(float deltaTime)
        {
            if (DisableCrewAI || Character.Removed) { return; }
@@ -176,15 +183,38 @@ namespace Barotrauma
                IgnoredItems.Clear();
            }

-            // Use the pathfinding also outside of the sub, but not farther than the extents of the sub + 500 units.
-            if (Character.Submarine != null || SelectedAiTarget?.Entity?.Submarine is Submarine sub && sub != null &&
-                    Vector2.DistanceSquared(Character.WorldPosition, sub.WorldPosition) < MathUtils.Pow(Math.Max(sub.Borders.Size.X, sub.Borders.Size.Y) / 2 + 500, 2))
+            bool IsCloseEnoughToTargetSub(float threshold) => SelectedAiTarget?.Entity?.Submarine is Submarine sub && sub != null && Vector2.DistanceSquared(Character.WorldPosition, sub.WorldPosition) < MathUtils.Pow(Math.Max(sub.Borders.Size.X, sub.Borders.Size.Y) / 2 + threshold, 2);
+            bool hasValidPath = steeringManager is IndoorsSteeringManager pathSteering && pathSteering.CurrentPath != null && !pathSteering.CurrentPath.Finished && !pathSteering.CurrentPath.Unreachable;
+
+            if (Character.Submarine == null && hasValidPath)
+            {
+                obstacleRaycastTimer -= deltaTime;
+                if (obstacleRaycastTimer <= 0)
+                {
+                    obstacleRaycastTimer = obstacleRaycastInterval;
+                    // Swimming outside and using the path finder -> check that the path is not blocked with anything (the path finder doesn't know about other subs).
+                    foreach (var connectedSub in Submarine.MainSub.GetConnectedSubs())
+                    {
+                        if (connectedSub == Submarine.MainSub) { continue; }
+                        Vector2 rayStart = SimPosition - connectedSub.SimPosition;
+                        Vector2 dir = PathSteering.CurrentPath.CurrentNode.WorldPosition - WorldPosition;
+                        Vector2 rayEnd = rayStart + dir.ClampLength(Character.AnimController.Collider.GetLocalFront().Length() * 5);
+                        if (Submarine.CheckVisibility(rayStart, rayEnd, ignoreSubs: true) != null)
+                        {
+                            PathSteering.CurrentPath.Unreachable = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (Character.Submarine != null || hasValidPath && IsCloseEnoughToTargetSub(maxSteeringBuffer) || IsCloseEnoughToTargetSub(steeringBuffer))
            {
                if (steeringManager != insideSteering)
                {
                    insideSteering.Reset();
                }
                steeringManager = insideSteering;
+                steeringBuffer += steeringBufferIncreaseSpeed * deltaTime;
            }
            else
            {
@@ -193,7 +223,9 @@ namespace Barotrauma
                    outsideSteering.Reset();
                }
                steeringManager = outsideSteering;
+                steeringBuffer = minSteeringBuffer;
            }
+            steeringBuffer = Math.Clamp(steeringBuffer, minSteeringBuffer, maxSteeringBuffer);

            AnimController.Crouching = shouldCrouch;
            CheckCrouching(deltaTime);
@@ -369,7 +401,7 @@ namespace Barotrauma
                if (!NeedsDivingGear(Character.CurrentHull, out bool needsSuit) || !needsSuit || oxygenLow)
                {
                    bool shouldKeepTheGearOn = Character.AnimController.HeadInWater
-                        || Character.Submarine.TeamID != Character.TeamID && Character.Submarine.TeamID != Character.TeamType.FriendlyNPC
+                        || Character.Submarine.TeamID != Character.TeamID
                        || ObjectiveManager.IsCurrentObjective<AIObjectiveFindSafety>()
                        || ObjectiveManager.CurrentOrder is AIObjectiveGoTo goTo && goTo.Target == Character   // wait order
                        || ObjectiveManager.CurrentObjective.GetSubObjectivesRecursive(true).Any(o => o.KeepDivingGearOn);
@@ -435,6 +467,7 @@ namespace Barotrauma
                            if (oxygenLow || ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
                            {
                                divingSuit.Drop(Character);
+                                HandleRelocation(divingSuit);
                            }
                            else if (findItemState == FindItemState.None || findItemState == FindItemState.DivingSuit)
                            {
@@ -461,6 +494,7 @@ namespace Barotrauma
                                    else
                                    {
                                        divingSuit.Drop(Character);
+                                        HandleRelocation(divingSuit);
                                    }
                                }
                            }
@@ -478,6 +512,7 @@ namespace Barotrauma
                                    if (ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
                                    {
                                        mask.Drop(Character);
+                                        HandleRelocation(mask);
                                    }
                                    else if (findItemState == FindItemState.None || findItemState == FindItemState.DivingMask)
                                    {
@@ -501,6 +536,7 @@ namespace Barotrauma
                                            else
                                            {
                                                mask.Drop(Character);
+                                                HandleRelocation(mask);
                                            }
                                        }
                                    }
@@ -548,6 +584,7 @@ namespace Barotrauma
                                else
                                {
                                    item.Drop(Character);
+                                    HandleRelocation(item);
                                }
                            }
                        }
@@ -556,6 +593,62 @@ namespace Barotrauma
            }
        }

+        private readonly HashSet<Item> itemsToRelocate = new HashSet<Item>();
+
+        private void HandleRelocation(Item item)
+        {
+            if (item.Submarine?.TeamID == Character.TeamType.FriendlyNPC)
+            {
+                if (itemsToRelocate.Contains(item)) { return; }
+                itemsToRelocate.Add(item);
+                if (item.Submarine.ConnectedDockingPorts.TryGetValue(Submarine.MainSub, out DockingPort myPort))
+                {
+                    myPort.OnUnDocked += Relocate;
+                }
+                var campaign = GameMain.GameSession.Campaign;
+                if (campaign != null)
+                {
+                    // In the campaign mode, undocking happens after leaving the outpost, so we can't use that.
+                    campaign.BeforeLevelLoading += Relocate;
+                }
+            }
+
+            void Relocate()
+            {
+                if (item == null || item.Removed) { return; }
+                if (!itemsToRelocate.Contains(item)) { return; }
+                var mainSub = Submarine.MainSub;
+                if (item.ParentInventory != null)
+                {
+                    if (item.ParentInventory.Owner is Character c)
+                    {
+                        if (c.TeamID == Character.TeamType.Team1 || c.TeamID == Character.TeamType.Team2)
+                        {
+                            // Taken by a player/bot (if npc or monster would take the item, we'd probably still want it to spawn back to the main sub.
+                            return;
+                        }
+                    }
+                    else if (item.ParentInventory.Owner.Submarine == mainSub)
+                    {
+                        // Placed inside an inventory that's already in the main sub.
+                        return;
+                    }
+                }
+                // Laying on ground inside the main sub.
+                if (item.Submarine == mainSub)
+                {
+                    return;
+                }
+                WayPoint wp = WayPoint.GetRandom(SpawnType.Cargo, null, mainSub);
+                if (wp != null)
+                {
+                    item.Submarine = mainSub;
+                    item.SetTransform(wp.SimPosition, 0.0f);
+                }
+                itemsToRelocate.Remove(item);
+            }
+        }
+
        public void ReequipUnequipped()
        {
            foreach (var item in unequippedItems)
@@ -585,6 +678,7 @@ namespace Barotrauma
            suitableContainer = null;
            if (character.FindItem(ref itemIndex, out Item targetContainer, ignoredItems: ignoredItems, customPriorityFunction: i =>
            {
+                if (i.IsThisOrAnyContainerIgnoredByAI()) { return 0; }
                var container = i.GetComponent<ItemContainer>();
                if (container == null) { return 0; }
                if (container.Inventory.IsFull()) { return 0; }
@@ -1223,6 +1317,14 @@ namespace Barotrauma
                    }
                    //if (!otherCharacter.IsFacing(thief.WorldPosition)) { continue; }
                    if (!otherCharacter.CanSeeCharacter(thief)) { continue; }
+                    // Don't react if the player is taking an extinguisher and there's any fires on the sub, or diving gear when the sub is flooding
+                    // -> allow them to use the emergency items
+                    if (character.Submarine != null)
+                    {
+                        var connectedHulls = character.Submarine.GetHulls(alsoFromConnectedSubs: true);
+                        if (item.HasTag("fireextinguisher") && connectedHulls.Any(h => h.FireSources.Any())) { continue; }
+                        if (item.HasTag("diving") && connectedHulls.Any(h => h.ConnectedGaps.Any(g => AIObjectiveFixLeaks.IsValidTarget(g, thief)))) { continue; }
+                    }
                    if (!someoneSpoke && !character.IsIncapacitated && character.Stun <= 0.0f)
                    {
                        if (!item.StolenDuringRound && GameMain.GameSession?.Campaign?.Map?.CurrentLocation != null)
@@ -1236,8 +1338,6 @@ namespace Barotrauma
                        otherCharacter.Speak(TextManager.Get("dialogstealwarning"), null, Rand.Range(0.5f, 1.0f), "thief", 10.0f);
                        someoneSpoke = true;
                    }
-                    // Don't react if the player is taking an extinguisher and there's any fires on the sub -> allow them to use the emergency items
-                    if (item.HasTag("fireextinguisher") && character.Submarine.GetHulls(alsoFromConnectedSubs: true).Any(h => h.FireSources.Any())) { continue; }
                    // React if we are security
                    if (!TriggerSecurity(otherHumanAI))
                    {
@@ -1464,7 +1564,16 @@ namespace Barotrauma
                // The hull safety decreases 90% per enemy up to 100% (TODO: test smaller percentages)
                enemyFactor = MathHelper.Lerp(1, 0, MathHelper.Clamp(enemyCount * 0.9f, 0, 1));
            }
-            float safety = oxygenFactor * waterFactor * fireFactor * enemyFactor;
+            float dangerousItemsFactor = 1f;
+            foreach (Item item in Item.ItemList.Where(it => it.CurrentHull == hull))
+            {
+                if (item.Prefab != null && item.Prefab.IsDangerous)
+                {
+                    dangerousItemsFactor = 0;
+                }
+            }
+
+            float safety = oxygenFactor * waterFactor * fireFactor * enemyFactor * dangerousItemsFactor;
            return MathHelper.Clamp(safety * 100, 0, 100);
        }

@@ -192,13 +192,43 @@ namespace Barotrauma
                    pathFinder.InsideSubmarine = character.Submarine != null;
                    pathFinder.ApplyPenaltyToOutsideNodes = character.PressureProtection <= 0;
                    var newPath = pathFinder.FindPath(currentPos, target, character.Submarine, "(Character: " + character.Name + ")", startNodeFilter, endNodeFilter, nodeFilter, checkVisibility: checkVisibility);
-                    bool useNewPath = needsNewPath || currentPath == null || currentPath.CurrentNode == null || findPathTimer < -1;
+                    bool useNewPath = needsNewPath || currentPath == null || currentPath.CurrentNode == null || findPathTimer < -1 && Math.Abs(character.AnimController.TargetMovement.X) <= 0;
                    if (!useNewPath && currentPath != null && currentPath.CurrentNode != null && newPath.Nodes.Any() && !newPath.Unreachable)
                    {
-                        // It's possible that the current path was calculated from a start point that is no longer valid.
-                        // Therefore, let's accept also paths with a greater cost than the current, if the current node is much farther than the new start node.
-                        useNewPath = newPath.Cost < currentPath.Cost ||
-                            Vector2.DistanceSquared(character.WorldPosition, currentPath.CurrentNode.WorldPosition) > Math.Pow(Vector2.Distance(character.WorldPosition, newPath.Nodes.First().WorldPosition) * 3, 2);
+                        // Check if the new path is the same as the old, in which case we just ignore it and continue using the old path (or the progress would reset).
+                        if (IsIdenticalPath())
+                        {
+                            useNewPath = false;
+                        }
+                        else
+                        {
+                            // Use the new path if it has significantly lower cost (don't change the path if it has marginally smaller cost. This reduces navigating backwards due to new path that is calculated from the node just behind us).
+                            float t = (float)currentPath.CurrentIndex / (currentPath.Nodes.Count - 1);
+                            useNewPath = newPath.Cost < currentPath.Cost * MathHelper.Lerp(0.95f, 0, t);
+                            if (!useNewPath)
+                            {
+                                // It's possible that the current path was calculated from a start point that is no longer valid.
+                                // Therefore, let's accept also paths with a greater cost than the current, if the current node is much farther than the new start node.
+                                useNewPath = Vector2.DistanceSquared(character.WorldPosition, currentPath.CurrentNode.WorldPosition) > Math.Pow(Vector2.Distance(character.WorldPosition, newPath.Nodes.First().WorldPosition) * 3, 2);
+                            }
+                        }
+
+                        bool IsIdenticalPath()
+                        {
+                            int nodeCount = newPath.Nodes.Count;
+                            if (nodeCount == currentPath.Nodes.Count)
+                            {
+                                for (int i = 0; i < nodeCount - 1; i++)
+                                {
+                                    if (newPath.Nodes[i] != currentPath.Nodes[i])
+                                    {
+                                        return false;
+                                    }
+                                }
+                                return true;
+                            }
+                            return false;
+                        }
                    }
                    if (useNewPath)
                    {
@@ -407,7 +437,7 @@ namespace Barotrauma
            if (door.IsOpen) { return true; }
            if (door.Item.NonInteractable) { return false; }
            if (CanBreakDoors) { return true; }
-            if (door.IsStuck) { return false; }
+            if (door.IsStuck || door.IsJammed) { return false; }
            if (!canOpenDoors || character.LockHands) { return false; }
            if (door.HasIntegratedButtons)
            {
@@ -689,7 +719,10 @@ namespace Barotrauma
            if (wander)
            {
                SteeringWander();
-                SteeringAvoid(deltaTime, lookAheadDistance: ConvertUnits.ToSimUnits(wallAvoidDistance), 5);
+                if (inWater)
+                {
+                    SteeringAvoid(deltaTime, lookAheadDistance: ConvertUnits.ToSimUnits(wallAvoidDistance), 5);
+                }
            }
            if (!inWater)
            {
@@ -15,15 +15,16 @@ namespace Barotrauma

        private float raycastTimer;

-        private Body attachTargetBody;
+        private Structure targetWall;
+        private Body targetBody;
        private Vector2 attachSurfaceNormal;
-        private Submarine attachTargetSubmarine;
+        private Submarine targetSubmarine;

        public bool AttachToSub { get; private set; }
        public bool AttachToWalls { get; private set; }

-        private float minDeattachSpeed = 3.0f, maxDeattachSpeed = 10.0f;
-        private float damageOnDetach = 0.0f, detachStun = 0.0f;
+        private readonly float minDeattachSpeed, maxDeattachSpeed;
+        private readonly float damageOnDetach, detachStun;
        private float deattachTimer;

        private Vector2 wallAttachPos;
@@ -35,13 +36,8 @@ namespace Barotrauma
        private float attachLimbRotation;

        private float jointDir;
-        
-        private List<WeldJoint> attachJoints = new List<WeldJoint>();

-        public List<WeldJoint> AttachJoints
-        {
-            get { return attachJoints; }
-        }
+        public List<WeldJoint> AttachJoints { get; } = new List<WeldJoint>();

        public Vector2? WallAttachPos
        {
@@ -49,19 +45,16 @@ namespace Barotrauma
            private set;
        }

-        public bool IsAttached
-        {
-            get { return attachJoints.Count > 0; }
-        }
+        public bool IsAttached => AttachJoints.Count > 0;

-        public bool IsAttachedToSub => IsAttached && (attachTargetBody?.UserData is Submarine || attachTargetBody?.UserData is Entity entity && entity.Submarine != null);
+        public bool IsAttachedToSub => IsAttached && targetSubmarine != null;

        public LatchOntoAI(XElement element, EnemyAIController enemyAI)
        {
            AttachToWalls = element.GetAttributeBool("attachtowalls", false);
            AttachToSub = element.GetAttributeBool("attachtosub", false);
-            minDeattachSpeed = element.GetAttributeFloat("mindeattachspeed", 3.0f);
-            maxDeattachSpeed = Math.Max(minDeattachSpeed, element.GetAttributeFloat("maxdeattachspeed", 10.0f));
+            minDeattachSpeed = element.GetAttributeFloat("mindeattachspeed", 5.0f);
+            maxDeattachSpeed = Math.Max(minDeattachSpeed, element.GetAttributeFloat("maxdeattachspeed", 8.0f));
            damageOnDetach = element.GetAttributeFloat("damageondetach", 0.0f);
            detachStun = element.GetAttributeFloat("detachstun", 0.0f);
            localAttachPos = ConvertUnits.ToSimUnits(element.GetAttributeVector2("localattachpos", Vector2.Zero));
@@ -84,10 +77,11 @@ namespace Barotrauma
            enemyAI.Character.OnDeath += OnCharacterDeath;
        }

-        public void SetAttachTarget(Body attachTarget, Submarine attachTargetSub, Vector2 attachPos, Vector2 attachSurfaceNormal)
+        public void SetAttachTarget(Structure wall, Vector2 attachPos, Vector2 attachSurfaceNormal)
        {
-            attachTargetBody = attachTarget;
-            attachTargetSubmarine = attachTargetSub;
+            targetWall = wall;
+            targetBody = wall.Submarine.PhysicsBody.FarseerBody;
+            targetSubmarine = wall.Submarine;
            this.attachSurfaceNormal = attachSurfaceNormal;
            wallAttachPos = attachPos;
        }
@@ -98,28 +92,27 @@ namespace Barotrauma

            if (character.Submarine != null)
            {
-                DeattachFromBody();
-                WallAttachPos = null;
+                DeattachFromBody(reset: true);
                return;
            }
-            if (attachJoints.Count > 0)
+            if (AttachJoints.Count > 0)
            {
                if (Math.Sign(attachLimb.Dir) != Math.Sign(jointDir))
                {
-                    attachJoints[0].LocalAnchorA =
-                        new Vector2(-attachJoints[0].LocalAnchorA.X, attachJoints[0].LocalAnchorA.Y);
-                    attachJoints[0].ReferenceAngle = -attachJoints[0].ReferenceAngle;
+                    AttachJoints[0].LocalAnchorA =
+                        new Vector2(-AttachJoints[0].LocalAnchorA.X, AttachJoints[0].LocalAnchorA.Y);
+                    AttachJoints[0].ReferenceAngle = -AttachJoints[0].ReferenceAngle;
                    jointDir = attachLimb.Dir;
                }
-                for (int i = 0; i < attachJoints.Count; i++)
+                for (int i = 0; i < AttachJoints.Count; i++)
                {
                    //something went wrong, limb body is very far from the joint anchor -> deattach
-                    if (Vector2.DistanceSquared(attachJoints[i].WorldAnchorB, attachJoints[i].BodyA.Position) > 10.0f * 10.0f)
+                    if (Vector2.DistanceSquared(AttachJoints[i].WorldAnchorB, AttachJoints[i].BodyA.Position) > 10.0f * 10.0f)
                    {
 #if DEBUG
                        DebugConsole.ThrowError("Limb body of the character \"" + character.Name + "\" is very far from the attach joint anchor -> deattach");
 #endif
-                        DeattachFromBody();
+                        DeattachFromBody(reset: true);
                        return;
                    }
                }
@@ -135,9 +128,9 @@ namespace Barotrauma
            }

            Vector2 transformedAttachPos = wallAttachPos;
-            if (character.Submarine == null && attachTargetSubmarine != null)
+            if (character.Submarine == null && targetSubmarine != null)
            {
-                transformedAttachPos += ConvertUnits.ToSimUnits(attachTargetSubmarine.Position);
+                transformedAttachPos += ConvertUnits.ToSimUnits(targetSubmarine.Position);
            }
            if (transformedAttachPos != Vector2.Zero)
            {
@@ -168,7 +161,7 @@ namespace Barotrauma
                                            if (MathUtils.GetLineIntersection(edge.Point1, edge.Point2, character.WorldPosition, cell.Center, out Vector2 intersection))
                                            {
                                                attachSurfaceNormal = edge.GetNormal(cell);
-                                                attachTargetBody = cell.Body;
+                                                targetBody = cell.Body;
                                                Vector2 potentialAttachPos = ConvertUnits.ToSimUnits(intersection);
                                                float distSqr = Vector2.DistanceSquared(character.SimPosition, wallAttachPos);
                                                if (distSqr < closestDist)
@@ -192,7 +185,7 @@ namespace Barotrauma

                    if (wallAttachPos == Vector2.Zero)
                    {
-                        DeattachFromBody();
+                        DeattachFromBody(reset: false);
                    }
                    else
                    {
@@ -201,13 +194,13 @@ namespace Barotrauma
                        if (squaredDistance < targetDistance * targetDistance)
                        {
                            //close enough to a wall -> attach
-                            AttachToBody(character.AnimController.Collider, attachLimb, attachTargetBody, wallAttachPos);
+                            AttachToBody(character.AnimController.Collider, attachLimb, targetBody, wallAttachPos);
                            enemyAI.SteeringManager.Reset();
                        }
                        else
                        {
                            //move closer to the wall
-                            DeattachFromBody();
+                            DeattachFromBody(reset: false);
                            enemyAI.SteeringManager.SteeringAvoid(deltaTime, 1.0f, 0.1f);
                            enemyAI.SteeringManager.SteeringSeek(wallAttachPos);
                        }
@@ -217,44 +210,60 @@ namespace Barotrauma
                case AIState.Aggressive:
                    if (enemyAI.AttackingLimb != null)
                    {
-                        if (AttachToSub && !enemyAI.IsSteeringThroughGap && wallAttachPos != Vector2.Zero && attachTargetBody != null)
+                        if (AttachToSub && !enemyAI.IsSteeringThroughGap && wallAttachPos != Vector2.Zero && targetBody != null)
                        {
                            // is not attached or is attached to something else
-                            if (!IsAttached || IsAttached && attachJoints[0].BodyB != attachTargetBody)
+                            if (!IsAttached || IsAttached && AttachJoints[0].BodyB != targetBody)
                            {
                                if (Vector2.DistanceSquared(ConvertUnits.ToDisplayUnits(transformedAttachPos), enemyAI.AttackingLimb.WorldPosition) < enemyAI.AttackingLimb.attack.DamageRange * enemyAI.AttackingLimb.attack.DamageRange)
                                {
-                                    AttachToBody(character.AnimController.Collider, attachLimb, attachTargetBody, transformedAttachPos);
+                                    AttachToBody(character.AnimController.Collider, attachLimb, targetBody, transformedAttachPos);
                                }
                            }
                        }
                    }
                    break;
                default:
-                    WallAttachPos = null;
-                    DeattachFromBody();
+                    DeattachFromBody(reset: true);
                    break;
            }

-            if (IsAttached && attachTargetBody != null && deattachTimer < 0.0f)
+            if (IsAttached && targetBody != null && targetWall != null && targetSubmarine != null && deattachTimer <= 0.0f)
            {
-                Entity entity = attachTargetBody.UserData as Entity;
-                Submarine attachedSub = entity is Submarine sub ? sub : entity?.Submarine;
-                if (attachedSub != null)
+                bool deattach = false;
+                // Deattach if the wall is broken enough where we are attached to
+                int targetSection = targetWall.FindSectionIndex(attachLimb.WorldPosition, world: true, clamp: true);
+                if (enemyAI.CanPassThroughHole(targetWall, targetSection))
                {
-                    float velocity = attachedSub.Velocity == Vector2.Zero ? 0.0f : attachedSub.Velocity.Length();
-                    float velocityFactor = (maxDeattachSpeed - minDeattachSpeed <= 0.0f) ?
-                        Math.Sign(Math.Abs(velocity) - minDeattachSpeed) :
-                        (Math.Abs(velocity) - minDeattachSpeed) / (maxDeattachSpeed - minDeattachSpeed);
-
-                    if (Rand.Range(0.0f, 1.0f) < velocityFactor)
+                    deattach = true;
+                    attachCooldown = 2;
+                }
+                if (!deattach)
+                {
+                    // Deattach if the velocity is high
+                    float velocity = targetSubmarine.Velocity == Vector2.Zero ? 0.0f : targetSubmarine.Velocity.Length();
+                    deattach = velocity > maxDeattachSpeed;
+                    if (!deattach)
                    {
-                        DeattachFromBody();
-                        character.AddDamage(character.WorldPosition, new List<Affliction>() { AfflictionPrefab.InternalDamage.Instantiate(damageOnDetach) }, detachStun, true);
-                        attachCooldown = 5.0f;
+                        if (velocity > minDeattachSpeed)
+                        {
+                            float velocityFactor = (maxDeattachSpeed - minDeattachSpeed <= 0.0f) ?
+                                Math.Sign(Math.Abs(velocity) - minDeattachSpeed) :
+                                (Math.Abs(velocity) - minDeattachSpeed) / (maxDeattachSpeed - minDeattachSpeed);
+
+                            if (Rand.Range(0.0f, 1.0f) < velocityFactor)
+                            {
+                                deattach = true;
+                                character.AddDamage(character.WorldPosition, new List<Affliction>() { AfflictionPrefab.InternalDamage.Instantiate(damageOnDetach) }, detachStun, true);
+                                attachCooldown = detachStun * 2;
+                            }
+                        }
                    }
                }
-
+                if (deattach)
+                {
+                    DeattachFromBody(reset: true);
+                }
                deattachTimer = 5.0f;
            }
        }
@@ -263,11 +272,11 @@ namespace Barotrauma
        {
            if (attachCooldown > 0) { return; }
            //already attached to something
-            if (attachJoints.Count > 0)
+            if (AttachJoints.Count > 0)
            {
                //already attached to the target body, no need to do anything
-                if (attachJoints[0].BodyB == targetBody) { return; }
-                DeattachFromBody();
+                if (AttachJoints[0].BodyB == targetBody) { return; }
+                DeattachFromBody(reset: false);
            }

            jointDir = attachLimb.Dir;
@@ -290,7 +299,7 @@ namespace Barotrauma
                CollideConnected = false,
            };
            GameMain.World.Add(limbJoint);
-            attachJoints.Add(limbJoint);
+            AttachJoints.Add(limbJoint);

            // Limb scale is already taken into account when creating the collider.
            Vector2 colliderFront = collider.GetLocalFront();
@@ -309,25 +318,37 @@ namespace Barotrauma
                //Length = 0.1f
            };
            GameMain.World.Add(colliderJoint);
-            attachJoints.Add(colliderJoint);            
+            AttachJoints.Add(colliderJoint);            
        }

-        public void DeattachFromBody(float cooldown = 0)
+        public void DeattachFromBody(bool reset, float cooldown = 0)
        {
-            foreach (Joint joint in attachJoints)
+            foreach (Joint joint in AttachJoints)
            {
                GameMain.World.Remove(joint);
            }
-            attachJoints.Clear();
+            AttachJoints.Clear();
            if (cooldown > 0)
            {
                attachCooldown = cooldown;
            }
+            if (reset)
+            {
+                Reset();
+            }
+        }
+
+        private void Reset()
+        {
+            targetWall = null;
+            targetSubmarine = null;
+            targetBody = null;
+            WallAttachPos = null;
        }

        private void OnCharacterDeath(Character character, CauseOfDeath causeOfDeath)
        {
-            DeattachFromBody();
+            DeattachFromBody(reset: true);
            character.OnDeath -= OnCharacterDeath;
        }
    }
@@ -20,6 +20,7 @@ namespace Barotrauma
        {
            if (battery == null) { return false; }
            var item = battery.Item;
+            if (item.IgnoreByAI) { return false; }
            if (item.NonInteractable) { return false; }
            if (item.Submarine == null) { return false; }
            if (item.CurrentHull == null) { return false; }
@@ -1,4 +1,5 @@
-using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
 using System.Collections.Generic;
 using System.Linq;

@@ -58,12 +59,10 @@ namespace Barotrauma
        public static bool IsValidTarget(Item item, Character character)
        {
            if (item == null) { return false; }
+            if (item.IgnoreByAI) { return false; }
            if (item.NonInteractable) { return false; }
            if (item.ParentInventory != null) { return false; }
            if (character != null && !IsItemInsideValidSubmarine(item, character)) { return false; }
-            //var rootContainer = item.GetRootContainer();
-            //// Only target items lying on the ground (= not inside a container) (do we need this check?)
-            //if (rootContainer != null) { return false; }
            var pickable = item.GetComponent<Pickable>();
            if (pickable == null) { return false; }
            if (pickable is Holdable h && h.Attachable && h.Attached) { return false; }
@@ -80,7 +79,28 @@ namespace Barotrauma
                    return false;
                }
            }
-            return item.Prefab.PreferredContainers.Any();
+            if (item.Prefab.PreferredContainers.None())
+            {
+                return false;
+            }
+            bool canEquip = true;
+            if (!item.AllowedSlots.Contains(InvSlotType.Any))
+            {
+                canEquip = false;
+                foreach (var allowedSlot in item.AllowedSlots)
+                {
+                    int slot = character.Inventory.FindLimbSlot(allowedSlot);
+                    if (slot > -1)
+                    {
+                        if (character.Inventory.Items[slot] == null)
+                        {
+                            canEquip = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            return canEquip;
        }
    }
 }
@@ -59,7 +59,7 @@ namespace Barotrauma
        protected override bool Check()
        {
            if (IsCompleted) { return true; }
-            if (container == null)
+            if (container == null || (container.Item != null && container.Item.IsThisOrAnyContainerIgnoredByAI()))
            {
                Abandon = true;
                return false;
@@ -86,7 +86,7 @@ namespace Barotrauma

        protected override void Act(float deltaTime)
        {
-            if (container == null)
+            if (container == null || (container.Item != null && container.Item.IsThisOrAnyContainerIgnoredByAI()))
            {
                Abandon = true;
                return;
@@ -94,6 +94,11 @@ namespace Barotrauma
            Item itemToContain = item ?? character.Inventory.FindItem(i => CheckItem(i) && i.Container != container.Item, recursive: true);
            if (itemToContain != null)
            {
+                if (!character.CanInteractWith(itemToContain))
+                {
+                    Abandon = true;
+                    return;
+                }
                if (character.CanInteractWith(container.Item, out _, checkLinked: false))
                {
                    if (RemoveEmpty)
@@ -142,11 +147,11 @@ namespace Barotrauma
                }
                else
                {
-                    // TODO: should we just use GetItem?
                    TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(container.Item, character, objectiveManager, getDivingGearIfNeeded: AllowToFindDivingGear)
                    {
                        DialogueIdentifier = "dialogcannotreachtarget",
-                        TargetName = container.Item.Name
+                        TargetName = container.Item.Name,
+                        abortCondition = () => !itemToContain.IsOwnedBy(character)
                    },
                    onAbandon: () => Abandon = true,
                    onCompleted: () => RemoveSubObjective(ref goToObjective));
@@ -79,11 +79,17 @@ namespace Barotrauma
                TryAddSubObjective(ref getExtinguisherObjective, () =>
                {
                    character.Speak(TextManager.Get("DialogFindExtinguisher"), null, 2.0f, "findextinguisher", 30.0f);
-                    return new AIObjectiveGetItem(character, "fireextinguisher", objectiveManager, equip: true)
+                    var getItemObjective = new AIObjectiveGetItem(character, "fireextinguisher", objectiveManager, equip: true)
                    {
+                        AllowStealing = true,
                        // If the item is inside an unsafe hull, decrease the priority
                        GetItemPriority = i => HumanAIController.UnsafeHulls.Contains(i.CurrentHull) ? 0.1f : 1
                    };
+                    if (objectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>())
+                    {
+                        getItemObjective.Abandoned += () => character.Speak(TextManager.Get("dialogcannotfindfireextinguisher"), null, 0.0f, "dialogcannotfindfireextinguisher", 10.0f);
+                    };
+                    return getItemObjective;
                });
            }
            else
@@ -38,6 +38,7 @@ namespace Barotrauma
        public static bool IsValidTarget(Hull hull, Character character)
        {
            if (hull == null) { return false; }
+            if (hull.IgnoreByAI) { return false; }
            if (hull.FireSources.None()) { return false; }
            if (hull.Submarine == null) { return false; }
            if (character.Submarine == null) { return false; }
@@ -46,6 +46,7 @@ namespace Barotrauma
                    }
                    return new AIObjectiveGetItem(character, gearTag, objectiveManager, equip: true)
                    {
+                        AllowStealing = true,
                        AllowToFindDivingGear = false,
                        AllowDangerousPressure = true
                    };
@@ -65,7 +65,14 @@ namespace Barotrauma
            if (weldingTool == null)
            {
                TryAddSubObjective(ref getWeldingTool, () => new AIObjectiveGetItem(character, "weldingequipment", objectiveManager, equip: true, spawnItemIfNotFound: character.TeamID == Character.TeamType.FriendlyNPC), 
-                    onAbandon: () => Abandon = true,
+                    onAbandon: () =>
+                    {
+                        if (objectiveManager.IsCurrentOrder<AIObjectiveFixLeaks>())
+                        {
+                            character.Speak(TextManager.Get("dialogcannotfindweldingequipment"), null, 0.0f, "dialogcannotfindweldingequipment", 10.0f);
+                        }
+                        Abandon = true;
+                    },
                    onCompleted: () => RemoveSubObjective(ref getWeldingTool));
                return;
            }
@@ -71,6 +71,8 @@ namespace Barotrauma
        public static bool IsValidTarget(Gap gap, Character character)
        {
            if (gap == null) { return false; }
+            // Don't fix a leak on a wall section set to be ignored
+            if (gap.ConnectedWall?.Sections?.Any(s => s.gap == gap && s.IgnoreByAI) ?? false) { return false; } 
            if (gap.ConnectedWall == null || gap.ConnectedDoor != null || gap.Open <= 0 || gap.linkedTo.All(l => l == null)) { return false; }
            if (gap.Submarine == null || character.Submarine == null) { return false; }
            // Don't allow going into another sub, unless it's connected and of the same team and type.
@@ -18,13 +18,13 @@ namespace Barotrauma
        public float TargetCondition { get; set; } = 1;
        public bool AllowDangerousPressure { get; set; }

-        private string[] identifiersOrTags;
+        private readonly string[] identifiersOrTags;

        //if the item can't be found, spawn it in the character's inventory (used by outpost NPCs)
        private bool spawnItemIfNotFound = false;

        private Item targetItem;
-        private Item originalTarget;
+        private readonly Item originalTarget;
        private ISpatialEntity moveToTarget;
        private bool isDoneSeeking;
        public Item TargetItem => targetItem;
@@ -32,13 +32,18 @@ namespace Barotrauma
        public string[] ignoredContainerIdentifiers;
        private AIObjectiveGoTo goToObjective;
        private float currItemPriority;
-        private bool checkInventory;
+        private readonly bool checkInventory;

        public static float DefaultReach = 100;

        public bool AllowToFindDivingGear { get; set; } = true;
        public bool MustBeSpecificItem { get; set; }

+        /// <summary>
+        /// Is the character allowed to take the item from somewhere else than their own sub (e.g. an outpost)
+        /// </summary>
+        public bool AllowStealing { get; set; }
+
        public AIObjectiveGetItem(Character character, Item targetItem, AIObjectiveManager objectiveManager, bool equip = true, float priorityModifier = 1) 
            : base(character, objectiveManager, priorityModifier)
        {
@@ -246,9 +251,13 @@ namespace Barotrauma
                currSearchIndex++;
                var item = Item.ItemList[currSearchIndex];
                Submarine itemSub = item.Submarine ?? item.ParentInventory?.Owner?.Submarine;
-                Submarine mySub = character.Submarine;
                if (itemSub == null) { continue; }
+                Submarine mySub = character.Submarine;
                if (mySub == null) { continue; }
+                if (!AllowStealing)
+                {
+                    if (character.TeamID == Character.TeamType.FriendlyNPC != item.SpawnedInOutpost) { continue; }
+                }
                if (!CheckItem(item)) { continue; }
                if (ignoredContainerIdentifiers != null && item.Container != null)
                {
@@ -339,6 +348,7 @@ namespace Barotrauma
        private bool CheckItem(Item item)
        {
            if (item.NonInteractable) { return false; }
+            if (item.IsThisOrAnyContainerIgnoredByAI()) { return false; }
            if (ignoredItems.Contains(item)) { return false; };
            if (item.Condition < TargetCondition) { return false; }
            if (ItemFilter != null && !ItemFilter(item)) { return false; }
@@ -362,14 +372,5 @@ namespace Barotrauma
            isDoneSeeking = false;
            currSearchIndex = 0;
        }
-
-        protected override void OnAbandon()
-        {
-            base.OnAbandon();
-            if (objectiveManager.CurrentOrder != null)
-            {
-                character.Speak(TextManager.Get("DialogCannotFindItem"), null, 0.0f, "cannotfinditem", 10.0f);
-            }
-        }
    }
 }
@@ -30,6 +30,8 @@ namespace Barotrauma
        public bool followControlledCharacter;
        public bool mimic;

+        public float extraDistanceWhileSwimming;
+        public float extraDistanceOutsideSub;
        private float _closeEnough = 50;
        private readonly float minDistance = 50;
        /// <summary>
@@ -37,7 +39,19 @@ namespace Barotrauma
        /// </summary>
        public float CloseEnough
        {
-            get { return _closeEnough; }
+            get
+            {
+                float dist = _closeEnough;
+                if (character.AnimController.InWater)
+                {
+                    dist += extraDistanceWhileSwimming;
+                }
+                if (character.CurrentHull == null)
+                {
+                    dist += extraDistanceOutsideSub;
+                }
+                return dist;
+            }
            set
            {
                _closeEnough = Math.Max(minDistance, value);
@@ -324,13 +338,15 @@ namespace Barotrauma
                    Func<PathNode, bool> nodeFilter = null;
                    if (isInside && !AllowGoingOutside)
                    {
-                        nodeFilter = node => node.Waypoint.CurrentHull != null;
+                        nodeFilter = n => n.Waypoint.CurrentHull != null;
                    }
-                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(Target), 1, n =>
-                    {
-                        if (n.Waypoint.isObstructed) { return false; }
-                        return (n.Waypoint.CurrentHull == null) == (character.CurrentHull == null);
-                    }, endNodeFilter, nodeFilter, CheckVisibility);
+
+                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(Target), 1, 
+                        startNodeFilter: n => (n.Waypoint.CurrentHull == null) == (character.CurrentHull == null), 
+                        endNodeFilter, 
+                        nodeFilter, 
+                        CheckVisibility);
+
                    if (!isInside && PathSteering.CurrentPath == null || PathSteering.IsPathDirty || PathSteering.CurrentPath.Unreachable)
                    {
                        if (useScooter)
@@ -21,14 +21,13 @@ namespace Barotrauma
            set
            {
                behavior = value;
+                if (behavior == BehaviorType.StayInHull && character.TeamID != Character.TeamType.FriendlyNPC)
+                {
+                    DebugConsole.NewMessage($"AIObjectiveIdle.BehaviorType.StayInHull is implemented only for outpost NPCs. Using passive behavior for {character.Name} ({character.Info.Job.Prefab.Identifier})", color: Color.Red);
+                    behavior = BehaviorType.Passive;
+                }
                switch (behavior)
                {
-                    case BehaviorType.Active:
-                        newTargetIntervalMin = 10;
-                        newTargetIntervalMax = 20;
-                        standStillMin = 2;
-                        standStillMax = 10;
-                        break;
                    case BehaviorType.Passive:
                    case BehaviorType.StayInHull:
                        newTargetIntervalMin = 60;
@@ -36,6 +35,18 @@ namespace Barotrauma
                        standStillMin = 30;
                        standStillMax = 60;
                        break;
+                    case BehaviorType.Active:
+                        newTargetIntervalMin = 40;
+                        newTargetIntervalMax = 60;
+                        standStillMin = 20;
+                        standStillMax = 40;
+                        break;
+                    case BehaviorType.Patrol:
+                        newTargetIntervalMin = 15;
+                        newTargetIntervalMax = 30;
+                        standStillMin = 5;
+                        standStillMax = 10;
+                        break;
                }
            }
        }
@@ -49,9 +60,10 @@ namespace Barotrauma

        public enum BehaviorType
        {
-            Active,
+            Patrol,
            Passive,
-            StayInHull
+            StayInHull,
+            Active
        }
        public Hull TargetHull { get; set; }
        private Hull currentTarget;
@@ -434,10 +446,11 @@ namespace Barotrauma
                    targetHulls.Add(hull);
                    float weight = hull.RectWidth;
                    // Prefer rooms that are closer. Avoid rooms that are not in the same level.
+                    // If the behavior is active, prefer rooms that are not close.
                    float yDist = Math.Abs(character.WorldPosition.Y - hull.WorldPosition.Y);
                    yDist = yDist > 100 ? yDist * 5 : 0;
                    float dist = Math.Abs(character.WorldPosition.X - hull.WorldPosition.X) + yDist;
-                    float distanceFactor = MathHelper.Lerp(1, 0, MathUtils.InverseLerp(0, 2500, dist));
+                    float distanceFactor = behavior == BehaviorType.Patrol ? MathHelper.Lerp(1, 0, MathUtils.InverseLerp(2500, 0, dist)) : MathHelper.Lerp(1, 0, MathUtils.InverseLerp(0, 2500, dist));
                    float waterFactor = MathHelper.Lerp(1, 0, MathUtils.InverseLerp(0, 100, hull.WaterPercentage * 2));
                    weight *= distanceFactor * waterFactor;
                    hullWeights.Add(weight);
@@ -245,7 +245,10 @@ namespace Barotrauma
        public void SortObjectives()
        {
            CurrentOrder?.GetPriority();
-            Objectives.ForEach(o => o.GetPriority());
+            for (int i = Objectives.Count - 1; i >= 0; i--)
+            {
+                Objectives[i].GetPriority();
+            }
            if (Objectives.Any())
            {
                Objectives.Sort((x, y) => y.Priority.CompareTo(x.Priority));
@@ -305,6 +308,8 @@ namespace Barotrauma
                    newObjective = new AIObjectiveGoTo(orderGiver, character, this, repeat: true, priorityModifier: priorityModifier)
                    {
                        CloseEnough = Rand.Range(90, 100) + Rand.Range(50, 70) * Math.Min(HumanAIController.CountCrew(c => c.ObjectiveManager.CurrentOrder is AIObjectiveGoTo gotoOrder && gotoOrder.Target == orderGiver, onlyBots: true), 4),
+                        extraDistanceOutsideSub = 100,
+                        extraDistanceWhileSwimming = 100,
                        AllowGoingOutside = true,
                        IgnoreIfTargetDead = true,
                        followControlledCharacter = orderGiver == character,
@@ -157,11 +157,20 @@ namespace Barotrauma
                Abandon = true;
                return;
            }
-            // Don't allow to operate an item that someone with a better skills already operates, unless this is an order
-            if (objectiveManager.CurrentOrder != this && HumanAIController.IsItemOperatedByAnother(target, out _))
+            // If this is not an order...
+            if (objectiveManager.CurrentOrder != this)
            {
-                // Don't abandon
-                return;
+                // Don't allow to operate an item that someone with a better skills already operates
+                if (HumanAIController.IsItemOperatedByAnother(target, out _))
+                {
+                    // Don't abandon
+                    return;
+                }
+                if (component.Item.IgnoreByAI || (useController && controller.Item.IgnoreByAI))
+                {
+                    Abandon = true;
+                    return;
+                }
            }
            if (operateTarget != null)
            {
@@ -27,6 +27,7 @@ namespace Barotrauma
        protected override bool Filter(Pump pump)
        {
            if (pump == null) { return false; }
+            if (pump.Item.IgnoreByAI) { return false; }
            if (pump.Item.NonInteractable) { return false; }
            if (pump.Item.HasTag("ballast")) { return false; }
            if (pump.Item.Submarine == null) { return false; }
@@ -90,7 +90,12 @@ namespace Barotrauma
                    {
                        foreach (RelatedItem requiredItem in kvp.Value)
                        {
-                            subObjectives.Add(new AIObjectiveGetItem(character, requiredItem.Identifiers, objectiveManager, true));
+                            var getItemObjective = new AIObjectiveGetItem(character, requiredItem.Identifiers, objectiveManager, true);
+                            if (objectiveManager.IsCurrentOrder<AIObjectiveRepairItems>())
+                            {
+                                getItemObjective.Abandoned += () => character.Speak(TextManager.Get("dialogcannotfindrequireditemtorepair"), null, 0.0f, "dialogcannotfindrequireditemtorepair", 10.0f);
+                            }
+                            subObjectives.Add(getItemObjective);
                        }
                    }
                    return;
@@ -148,6 +148,7 @@ namespace Barotrauma
        public static bool IsValidTarget(Item item, Character character)
        {
            if (item == null) { return false; }
+            if (item.IgnoreByAI) { return false; }
            if (item.NonInteractable) { return false; }
            if (item.IsFullCondition) { return false; }
            if (item.CurrentHull == null) { return false; }
@@ -94,7 +94,9 @@ namespace Barotrauma


        //if true, the order is issued to all available characters
-        public bool TargetAllCharacters;
+        public bool TargetAllCharacters { get; }
+        public bool IsReport => TargetAllCharacters && !MustSetTarget;
+

        public readonly float FadeOutTime;

@@ -132,11 +134,31 @@ namespace Barotrauma
        {
            get
            {
-                if (targetSpatialEntity == null) { targetSpatialEntity = TargetEntity ?? TargetPosition as ISpatialEntity; }
+                if (targetSpatialEntity == null)
+                {
+                    if (TargetType == OrderTargetType.WallSection && WallSectionIndex.HasValue)
+                    {
+                        targetSpatialEntity = (TargetEntity as Structure)?.Sections[WallSectionIndex.Value];
+                    }
+                    else
+                    {
+                        targetSpatialEntity = TargetEntity ?? TargetPosition as ISpatialEntity;
+                    }
+                }
                return targetSpatialEntity;
            }
        }

+        public enum OrderTargetType
+        {
+            Entity,
+            Position,
+            WallSection
+        }
+        public OrderTargetType TargetType { get; }
+        public int? WallSectionIndex { get; }
+        public bool IsIgnoreOrder { get; }
+
        public static void Init()
        {
            Prefabs = new Dictionary<string, Order>();
@@ -292,6 +314,7 @@ namespace Barotrauma

            IsPrefab = true;
            MustManuallyAssign = orderElement.GetAttributeBool("mustmanuallyassign", false);
+            IsIgnoreOrder = Identifier == "ignorethis" || Identifier == "unignorethis";
        }

        /// <summary>
@@ -299,7 +322,7 @@ namespace Barotrauma
        /// </summary>
        public Order(Order prefab, Entity targetEntity, ItemComponent targetItem, Character orderGiver = null, bool isAutonomous = false)
        {
-            Prefab = prefab;
+            Prefab = prefab.Prefab ?? prefab;

            Name                = prefab.Name;
            Identifier          = prefab.Identifier;
@@ -317,6 +340,7 @@ namespace Barotrauma
            AppropriateSkill    = prefab.AppropriateSkill;
            Category            = prefab.Category;
            MustManuallyAssign  = prefab.MustManuallyAssign;
+            IsIgnoreOrder       = prefab.IsIgnoreOrder;

            OrderGiver = orderGiver;
            TargetEntity = targetEntity;
@@ -337,12 +361,21 @@ namespace Barotrauma
                TargetItemComponent = targetItem;
            }

+            TargetType = OrderTargetType.Entity;
+
            IsPrefab = false;
        }

        public Order(Order prefab, OrderTarget target, Character orderGiver = null) : this(prefab, targetEntity: null, targetItem: null, orderGiver)
        {
            TargetPosition = target;
+            TargetType = OrderTargetType.Position;
+        }
+
+        public Order(Order prefab, Structure wall, int? sectionIndex, Character orderGiver = null) : this(prefab, targetEntity: wall, null, orderGiver: orderGiver)
+        {
+            WallSectionIndex = sectionIndex;
+            TargetType = OrderTargetType.WallSection;
        }
        
        public bool HasAppropriateJob(Character character)
@@ -7,41 +7,32 @@ namespace Barotrauma
 {
    class PathNode
    {
-        private readonly int wayPointID;
-
        public int state;

        public PathNode Parent;

-        private Vector2 position;
-
        public float F, G, H;

-        public List<PathNode> connections;
+        public readonly List<PathNode> connections = new List<PathNode>();
        public List<float> distances;

        public Vector2 TempPosition;
        public float TempDistance;

-        public WayPoint Waypoint { get; private set; }
-
-        public Vector2 Position
-        {
-            get { return position; }
-        }
+        public readonly WayPoint Waypoint;
+        public readonly Vector2 Position;
+        public readonly int WayPointID;

        public override string ToString()
        {
-            return $"PathNode {wayPointID}";
+            return $"PathNode {WayPointID}";
        }

        public PathNode(WayPoint wayPoint)
        {
-            this.Waypoint = wayPoint;
-            this.position = wayPoint.SimPosition;
-            wayPointID = wayPoint.ID;
-
-            connections = new List<PathNode>();
+            Waypoint = wayPoint;
+            Position = wayPoint.SimPosition;
+            WayPointID = Waypoint.ID;
        }

        public static List<PathNode> GenerateNodes(List<WayPoint> wayPoints)
@@ -78,7 +69,7 @@ namespace Barotrauma
                node.distances = new List<float>();
                for (int i = 0; i < node.connections.Count; i++)
                {
-                    node.distances.Add(Vector2.Distance(node.position, node.connections[i].position));
+                    node.distances.Add(Vector2.Distance(node.Position, node.connections[i].Position));
                }
            }

@@ -92,6 +83,7 @@ namespace Barotrauma
        public GetNodePenaltyHandler GetNodePenalty;

        private readonly List<PathNode> nodes;
+        public readonly bool IndoorsSteering;

        public bool InsideSubmarine { get; set; }
        public bool ApplyPenaltyToOutsideNodes { get; set; }
@@ -105,7 +97,7 @@ namespace Barotrauma
                wp.linkedTo.CollectionChanged += WaypointLinksChanged;
            }

-            InsideSubmarine = indoorsSteering;
+            IndoorsSteering = indoorsSteering;
        }

        void WaypointLinksChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
@@ -201,11 +193,13 @@ namespace Barotrauma
                    if (nodeFilter != null && !nodeFilter(node)) { continue; }
                    if (startNodeFilter != null && !startNodeFilter(node)) { continue; }
                    //if searching for a path inside the sub, make sure the waypoint is visible
-                    if (InsideSubmarine)
+                    if (IndoorsSteering)
                    {
+                        if (node.Waypoint.isObstructed) { continue; }
+
                        // Always check the visibility for the start node
                        var body = Submarine.PickBody(
-                            start, node.TempPosition, null, 
+                            start, node.TempPosition, null,
                            Physics.CollisionWall | Physics.CollisionLevel | Physics.CollisionStairs);
                        if (body != null)
                        {
@@ -259,17 +253,20 @@ namespace Barotrauma
                {
                    if (nodeFilter != null && !nodeFilter(node)) { continue; }
                    if (endNodeFilter != null && !endNodeFilter(node)) { continue; }
-
-                    //if searching for a path inside the sub, make sure the waypoint is visible
-                    if (InsideSubmarine && checkVisibility)
+                    if (IndoorsSteering)
                    {
-                        // Only check the visibility for the end node when allowed (fix leaks)
-                        var body = Submarine.PickBody(end, node.TempPosition, null,
-                            Physics.CollisionWall | Physics.CollisionLevel | Physics.CollisionStairs );
-                        if (body != null)
+                        if (node.Waypoint.isObstructed) { continue; }
+                        //if searching for a path inside the sub, make sure the waypoint is visible
+                        if (checkVisibility)
                        {
-                            if (body.UserData is Structure && !((Structure)body.UserData).IsPlatform) { continue; }
-                            if (body.UserData is Item && body.FixtureList[0].CollisionCategories.HasFlag(Physics.CollisionWall)) { continue; }
+                            // Only check the visibility for the end node when allowed (fix leaks)
+                            var body = Submarine.PickBody(end, node.TempPosition, null,
+                                Physics.CollisionWall | Physics.CollisionLevel | Physics.CollisionStairs);
+                            if (body != null)
+                            {
+                                if (body.UserData is Structure && !((Structure)body.UserData).IsPlatform) { continue; }
+                                if (body.UserData is Item && body.FixtureList[0].CollisionCategories.HasFlag(Physics.CollisionWall)) { continue; }
+                            }
                        }
                    }
                    endNode = node;
@@ -343,6 +340,7 @@ namespace Barotrauma
                foreach (PathNode node in nodes)
                {
                    if (node.state != 1) { continue; }
+                    if (IndoorsSteering && node.Waypoint.isObstructed) { continue; }
                    if (filter != null && !filter(node)) { continue; }
                    if (node.F < dist)
                    {
@@ -1,5 +1,6 @@
 using Barotrauma.Extensions;
 using Barotrauma.Items.Components;
+using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System.Collections.Generic;
 using System.Globalization;
@@ -18,8 +19,19 @@ namespace Barotrauma
            Hungry
        }

-        public float Hunger { get; set; } = 50.0f;
-        public float Happiness { get; set; } = 50.0f;
+        private float hunger = 50.0f;
+        public float Hunger 
+        { 
+            get { return hunger; }
+            set { hunger = MathHelper.Clamp(value, 0.0f, MaxHunger); }
+        }
+
+        private float happiness = 50.0f;
+        public float Happiness
+        {
+            get { return happiness; }
+            set { happiness = MathHelper.Clamp(value, 0.0f, MaxHappiness); }
+        }

        public float MaxHappiness { get; set; }
        public float MaxHunger { get; set; }
@@ -86,9 +98,10 @@ namespace Barotrauma
                    switch (subElement.Name.LocalName.ToLowerInvariant())
                    {
                        case "item":
+                            string identifier = subElement.GetAttributeString("identifier", "");
                            Item newItemToProduce = new Item
                            {
-                                Prefab = ItemPrefab.Find("", subElement.GetAttributeString("identifier", "")),
+                                Prefab = string.IsNullOrEmpty(identifier) ? null : ItemPrefab.Find("", subElement.GetAttributeString("identifier", "")),
                                Commonness = subElement.GetAttributeFloat("commonness", 0.0f)
                            };
                            totalCommonness += newItemToProduce.Commonness;
@@ -119,7 +132,7 @@ namespace Barotrauma
                    for (int i = 0; i < Items.Count; i++)
                    {
                        aggregate += Items[i].Commonness;
-                        if (aggregate >= r)
+                        if (aggregate >= r && Items[i].Prefab != null)
                        {
                            Entity.Spawner.AddToSpawnQueue(Items[i].Prefab, pet.AiController.Character.WorldPosition);
                            break;
@@ -192,25 +205,21 @@ namespace Barotrauma
        public StatusIndicatorType GetCurrentStatusIndicatorType()
        {
            if (Hunger > MaxHunger * 0.5f) { return StatusIndicatorType.Hungry; }
-            if (Happiness > MaxHappiness * 0.75f) { return StatusIndicatorType.Happy; }
+            if (Happiness > MaxHappiness * 0.8f) { return StatusIndicatorType.Happy; }
            if (Happiness < MaxHappiness * 0.25f) { return StatusIndicatorType.Sad; }
            return StatusIndicatorType.None;
        }

-        public void OnEat(IEnumerable<string> tags, float amount)
+        public bool OnEat(IEnumerable<string> tags, float amount)
        {
-            for (int i = 0; i < foods.Count; i++)
+            foreach (string tag in tags)
            {
-                if (tags.Any(t => t.Equals(foods[i].Tag, System.StringComparison.OrdinalIgnoreCase)))
-                {
-                    Hunger += foods[i].Hunger * amount;
-                    Happiness += foods[i].Happiness * amount;
-                    break;
-                }
+               if (OnEat(tag, amount)) { return true; }
            }
+            return false;
        }

-        public void OnEat(string tag, float amount)
+        public bool OnEat(string tag, float amount)
        {
            for (int i = 0; i < foods.Count; i++)
            {
@@ -218,9 +227,13 @@ namespace Barotrauma
                {
                    Hunger += foods[i].Hunger * amount;
                    Happiness += foods[i].Happiness * amount;
-                    break;
+#if CLIENT
+                    AiController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.5f);
+#endif
+                    return true;
                }
            }
+            return false;
        }

        public void Play(Character player)
@@ -230,9 +243,11 @@ namespace Barotrauma
            PlayTimer = 5.0f;
            AiController.Character.IsRagdolled = true;
            Happiness += 10.0f;
-            if (Happiness > MaxHappiness) { Happiness = MaxHappiness; }
            AiController.Character.AnimController.MainLimb.body.LinearVelocity += new Vector2(0, PlayForce);
            unstunY = AiController.Character.SimPosition.Y;
+#if CLIENT
+            AiController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.9f);
+#endif
        }

        public string GetTagName()
@@ -259,15 +274,6 @@ namespace Barotrauma
        {
            var character = AiController.Character;
            if (character?.Removed ?? true || character.IsDead) { return; }
-            if (GameMain.NetworkMember?.IsClient ?? false) { return; }
-
-            if (Owner != null && (Owner.Removed || Owner.IsDead)) { Owner = null; }
-
-            Hunger += HungerIncreaseRate * deltaTime;
-
-            Happiness -= HappinessDecreaseRate * deltaTime;
-
-            PlayTimer -= deltaTime;

            if (unstunY.HasValue)
            {
@@ -292,6 +298,14 @@ namespace Barotrauma
                }
            }

+            PlayTimer -= deltaTime;
+
+            if (GameMain.NetworkMember?.IsClient ?? false) { return; }
+            if (Owner != null && (Owner.Removed || Owner.IsDead)) { Owner = null; }
+
+            Hunger += HungerIncreaseRate * deltaTime;
+            Happiness -= HappinessDecreaseRate * deltaTime;
+
            for (int i = 0; i < foods.Count; i++)
            {
                Food food = foods[i];
@@ -311,12 +325,6 @@ namespace Barotrauma
                }
            }

-            if (Hunger < 0.0f) { Hunger = 0.0f; }
-            if (Hunger > MaxHunger) { Hunger = MaxHunger; }
-            if (Happiness < 0.0f) { Happiness = 0.0f; }
-            if (Happiness > MaxHappiness) { Happiness = MaxHappiness; }
-            if (PlayTimer < 0.0f) { PlayTimer = 0.0f; }
-
            if (Hunger >= MaxHunger * 0.99f)
            {
                character.CharacterHealth.ApplyAffliction(character.AnimController.MainLimb, new Affliction(AfflictionPrefab.InternalDamage, 8.0f * deltaTime));
@@ -343,7 +351,7 @@ namespace Barotrauma
            foreach (Character c in Character.CharacterList)
            {
                if (!c.IsPet || c.IsDead) { continue; }
-                if (c.Submarine?.Info.Type != SubmarineType.Player) { continue; }
+                if (c.Submarine == null) { continue; }

                var petBehavior = (c.AIController as EnemyAIController)?.PetBehavior;
                if (petBehavior == null) { continue; }
@@ -396,14 +404,32 @@ namespace Barotrauma
                if (petBehavior != null)
                {
                    petBehavior.Owner = owner;
-                    var petBehaviorElement = subElement.Attribute("petbehavior");
+                    var petBehaviorElement = subElement.Element("petbehavior");
                    if (petBehaviorElement != null)
                    {
-                        petBehavior.Hunger = petBehaviorElement.GetAttributeFloat(50.0f);
-                        petBehavior.Happiness = petBehaviorElement.GetAttributeFloat(50.0f);
+                        petBehavior.Hunger = petBehaviorElement.GetAttributeFloat("hunger", 50.0f);
+                        petBehavior.Happiness = petBehaviorElement.GetAttributeFloat("happiness", 50.0f);
                    }
                }
+
+                var inventoryElement = subElement.Element("inventory");
+                if (inventoryElement != null)
+                {
+                    pet.SpawnInventoryItems(pet.Inventory, inventoryElement);
+                }
            }
        }
+
+        public void ServerWrite(IWriteMessage msg)
+        {
+            msg.WriteRangedSingle(Happiness, 0.0f, MaxHappiness, 8);
+            msg.WriteRangedSingle(Hunger, 0.0f, MaxHunger, 8);
+        }
+
+        public void ClientRead(IReadMessage msg)
+        {
+            Happiness = msg.ReadRangedSingle(0.0f, MaxHappiness, 8);
+            Hunger = msg.ReadRangedSingle(0.0f, MaxHunger, 8);
+        }
    }
 }