v0.10.6.2

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/AIController.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace Barotrauma
 {
-    public enum AIState { Idle, Attack, Escape, Eat, Flee, Avoid, Aggressive, PassiveAggressive, Protect }
+    public enum AIState { Idle, Attack, Escape, Eat, Flee, Avoid, Aggressive, PassiveAggressive, Protect, Observe, Freeze, Follow }
 
     abstract partial class AIController : ISteerable
     {
@@ -147,6 +147,8 @@ namespace Barotrauma
             _selectedAiTarget = null;
         }
 
+        public void FaceTarget(ISpatialEntity target) => Character.AnimController.TargetDir = target.WorldPosition.X > Character.WorldPosition.X ? Direction.Right : Direction.Left;
+
         protected virtual void OnStateChanged(AIState from, AIState to) { }
         protected virtual void OnTargetChanged(AITarget previousTarget, AITarget newTarget) { }
 

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/AITarget.cs

@@ -38,7 +38,7 @@ namespace Barotrauma
             {
                 if (float.IsNaN(value))
                 {
-                    DebugConsole.ThrowError("Attempted to set the SoundRange of an AITarget to NaN.\n" + Environment.StackTrace);
+                    DebugConsole.ThrowError("Attempted to set the SoundRange of an AITarget to NaN.\n" + Environment.StackTrace.CleanupStackTrace());
                     return;
                 }
                 soundRange = MathHelper.Clamp(value, MinSoundRange, MaxSoundRange); 
@@ -52,7 +52,7 @@ namespace Barotrauma
             {
                 if (float.IsNaN(value))
                 {
-                    DebugConsole.ThrowError("Attempted to set the SightRange of an AITarget to NaN.\n" + Environment.StackTrace);
+                    DebugConsole.ThrowError("Attempted to set the SightRange of an AITarget to NaN.\n" + Environment.StackTrace.CleanupStackTrace());
                     return;
                 }
                 sightRange = MathHelper.Clamp(value, MinSightRange, MaxSightRange); 
@@ -74,7 +74,7 @@ namespace Barotrauma
             {
                 if (!MathUtils.IsValid(value))
                 {
-                    string errorMsg = "Invalid AITarget sector direction (" + value + ")\n" + Environment.StackTrace;
+                    string errorMsg = "Invalid AITarget sector direction (" + value + ")\n" + Environment.StackTrace.CleanupStackTrace();
                     DebugConsole.ThrowError(errorMsg);
                     GameAnalyticsManager.AddErrorEventOnce("AITarget.SectorDir:" + entity?.ToString(), GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
                     return;
@@ -113,11 +113,11 @@ namespace Barotrauma
                 if (entity == null || entity.Removed)
                 {
 #if DEBUG
-                    DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace);
+                    DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                     GameAnalyticsManager.AddErrorEventOnce("AITarget.WorldPosition:EntityRemoved",
                         GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
-                        "Attempted to access a removed AITarget\n" + Environment.StackTrace);
+                        "Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
                     return Vector2.Zero;
                 }
 
@@ -132,11 +132,11 @@ namespace Barotrauma
                 if (entity == null || entity.Removed)
                 {
 #if DEBUG
-                    DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace);
+                    DebugConsole.ThrowError("Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                     GameAnalyticsManager.AddErrorEventOnce("AITarget.WorldPosition:EntityRemoved",
                         GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
-                        "Attempted to access a removed AITarget\n" + Environment.StackTrace);
+                        "Attempted to access a removed AITarget\n" + Environment.StackTrace.CleanupStackTrace());
                     return Vector2.Zero;
                 }
 

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/EnemyAIController.cs

@@ -48,13 +48,13 @@ namespace Barotrauma
         private float attackLimbResetTimer;
 
         private bool IsCoolDownRunning => AttackingLimb != null && AttackingLimb.attack.CoolDownTimer > 0;
-        public float CombatStrength => Character.Params.AI.CombatStrength;
-        private float Sight => Character.Params.AI.Sight;
-        private float Hearing => Character.Params.AI.Hearing;
-        private float FleeHealthThreshold => Character.Params.AI.FleeHealthThreshold;
-        private float AggressionGreed => Character.Params.AI.AggressionGreed;
-        private float AggressionHurt => Character.Params.AI.AggressionHurt;
-        private bool AggressiveBoarding => Character.Params.AI.AggressiveBoarding;
+        public float CombatStrength => AIParams.CombatStrength;
+        private float Sight => AIParams.Sight;
+        private float Hearing => AIParams.Hearing;
+        private float FleeHealthThreshold => AIParams.FleeHealthThreshold;
+        private bool AggressiveBoarding => AIParams.AggressiveBoarding;
+
+        private FishAnimController FishAnimController => Character.AnimController as FishAnimController;
 
         //a point in a wall which the Character is currently targeting
         private WallTarget wallTarget;
@@ -70,10 +70,6 @@ namespace Barotrauma
                 _attackingLimb = value;
                 attackVector = null;
                 Reverse = _attackingLimb != null && _attackingLimb.attack.Reverse;
-                if (Character.AnimController is FishAnimController fishController)
-                {
-                    fishController.reverse = Reverse;
-                }
             }
         }
         
@@ -92,14 +88,15 @@ namespace Barotrauma
 
         private readonly float priorityFearIncreasement = 2;
         private readonly float memoryFadeTime = 0.5f;
-        private readonly float avoidTime = 3;
 
         private float avoidTimer;
+        private float observeTimer;
 
         public bool StayInsideLevel = true;
 
         public LatchOntoAI LatchOntoAI { get; private set; }
         public SwarmBehavior SwarmBehavior { get; private set; }
+        public PetBehavior PetBehavior { get; private set; }
 
         public CharacterParams.TargetParams SelectedTargetingParams { get { return selectedTargetingParams; } }
 
@@ -107,7 +104,7 @@ namespace Barotrauma
         {
             get
             {
-                var target = GetTarget(CharacterPrefab.HumanSpeciesName);
+                var target = GetTargetParams(CharacterPrefab.HumanSpeciesName);
                 return target != null && target.Priority > 0.0f && (target.State == AIState.Attack || target.State == AIState.Aggressive);
             }
         }
@@ -116,7 +113,7 @@ namespace Barotrauma
         {
             get
             {
-                var target = GetTarget("room");
+                var target = GetTargetParams("room");
                 return target != null && target.Priority > 0.0f && (target.State == AIState.Attack || target.State == AIState.Aggressive);
             }
         }
@@ -145,7 +142,19 @@ namespace Barotrauma
         public bool IsBeingChasedBy(Character c) => c.AIController is EnemyAIController enemyAI && enemyAI.SelectedAiTarget?.Entity is Character && (enemyAI.State == AIState.Aggressive || enemyAI.State == AIState.Attack);
         private bool IsBeingChased => SelectedAiTarget?.Entity is Character targetCharacter && IsBeingChasedBy(targetCharacter);
 
-        public bool Reverse { get; private set; }
+        private bool reverse;
+        public bool Reverse 
+        { 
+            get { return reverse; }
+            private set
+            {
+                reverse = value;
+                if (FishAnimController != null)
+                {
+                    FishAnimController.reverse = reverse;
+                }
+            }
+        }
 
         public EnemyAIController(Character c, string seed) : base(c)
         {
@@ -196,6 +205,9 @@ namespace Barotrauma
                     case "swarmbehavior":
                         SwarmBehavior = new SwarmBehavior(subElement, this);
                         break;
+                    case "petbehavior":
+                        PetBehavior = new PetBehavior(subElement, this);
+                        break;
                 }
             }
 
@@ -213,8 +225,74 @@ namespace Barotrauma
             avoidLookAheadDistance = Math.Max(colliderWidth * 3, 1.5f);
         }
 
-        private CharacterParams.AIParams AIParams => Character.Params.AI;
-        private CharacterParams.TargetParams GetTarget(string targetTag) => AIParams.GetTarget(targetTag, false);
+        public CharacterParams.AIParams AIParams => Character.Params.AI;
+        private CharacterParams.TargetParams GetTargetParams(string targetTag) => AIParams.GetTarget(targetTag, false);
+        private CharacterParams.TargetParams GetTargetParams(AITarget aiTarget) => GetTargetParams(GetTargetingTag(aiTarget));
+        private string GetTargetingTag(AITarget aiTarget)
+        {
+            if (aiTarget.Entity == null) { return null; }
+            string targetingTag = null;
+            if (aiTarget.Entity is Character targetCharacter)
+            {
+                if (targetCharacter.IsDead)
+                {
+                    targetingTag = "dead";
+                }
+                else if (PetBehavior != null && aiTarget.Entity == PetBehavior.Owner) 
+                { 
+                    targetingTag = "owner"; 
+                }
+                else if (AIParams.TryGetTarget(targetCharacter.SpeciesName, out CharacterParams.TargetParams tP))
+                {
+                    targetingTag = tP.Tag;
+                }
+                else if (targetCharacter.AIController is EnemyAIController enemy)
+                {
+                    if (targetCharacter.IsHusk && AIParams.HasTag("husk"))
+                    {
+                        targetingTag = "husk";
+                    }
+                    else
+                    {
+                        if (enemy.CombatStrength > CombatStrength)
+                        {
+                            targetingTag = "stronger";
+                        }
+                        else if (enemy.CombatStrength < CombatStrength)
+                        {
+                            targetingTag = "weaker";
+                        }
+                    }
+                }
+            }
+            else if (aiTarget.Entity is Item targetItem)
+            {
+                foreach (var prio in AIParams.Targets)
+                {
+                    if (targetItem.HasTag(prio.Tag))
+                    {
+                        targetingTag = prio.Tag;
+                        break;
+                    }
+                }
+                if (targetingTag == null)
+                {
+                    if (targetItem.GetComponent<Sonar>() != null)
+                    {
+                        targetingTag = "sonar";
+                    }
+                }
+            }
+            else if (aiTarget.Entity is Structure)
+            {
+                targetingTag = "wall";
+            }
+            else if (aiTarget.Entity is Hull)
+            {
+                targetingTag = "room";
+            }
+            return targetingTag;
+        }
 
         public override void SelectTarget(AITarget target) => SelectTarget(target, 100);
 
@@ -295,8 +373,9 @@ namespace Barotrauma
                 updateMemoriesTimer = updateMemoriesInverval;
             }
             if (Character.HealthPercentage <= FleeHealthThreshold && SelectedAiTarget != null && 
-                SelectedAiTarget.Entity is Character target && (target.IsPlayer || IsBeingChasedBy(target)))
+                SelectedAiTarget.Entity is Character target && (target.IsHuman && CanPerceive(SelectedAiTarget) || IsBeingChasedBy(target)))
             {
+                // Keep fleeing if being chased
                 State = AIState.Flee;
                 wallTarget = null;
             }
@@ -306,7 +385,7 @@ namespace Barotrauma
                 {
                     updateTargetsTimer -= deltaTime;
                 }
-                else
+                else if (avoidTimer <= 0)
                 {
                     CharacterParams.TargetParams targetingParams = null;
                     UpdateTargets(Character, out targetingParams);
@@ -315,11 +394,7 @@ namespace Barotrauma
                         UpdateWallTarget();
                     }
                     updateTargetsTimer = updateTargetsInterval * Rand.Range(0.75f, 1.25f);
-                    if (avoidTimer > 0)
-                    {
-                        State = AIState.Escape;
-                    }
-                    else if (SelectedAiTarget == null)
+                    if (SelectedAiTarget == null)
                     {
                         State = AIState.Idle;
                     }
@@ -348,9 +423,13 @@ namespace Barotrauma
                 steeringManager = insideSteering;
             }
 
+            bool useSteeringLengthAsMovementSpeed = State == AIState.Idle && Character.AnimController.InWater;
             bool run = false;
             switch (State)
             {
+                case AIState.Freeze:
+                    SteeringManager.Reset();
+                    break;
                 case AIState.Idle:
                     UpdateIdle(deltaTime);
                     break;
@@ -420,17 +499,21 @@ namespace Barotrauma
                     }
                     break;
                 case AIState.Protect:
+                case AIState.Follow:
                     if (SelectedAiTarget == null || SelectedAiTarget.Entity == null || SelectedAiTarget.Entity.Removed)
                     {
                         State = AIState.Idle;
                         return;
                     }
-                    if (SelectedAiTarget.Entity is Character targetCharacter && targetCharacter.LastAttacker is Character attacker)
+                    if (State == AIState.Protect)
                     {
-                        // Attack the character that attacked the target we are protecting
-                        ChangeTargetState(attacker, AIState.Attack, selectedTargetingParams.Priority * 2);
-                        SelectTarget(attacker.AiTarget);
-                        return;
+                        if (SelectedAiTarget.Entity is Character targetCharacter && targetCharacter.LastAttacker is Character attacker && !attacker.Removed && !attacker.IsDead)
+                        {
+                            // Attack the character that attacked the target we are protecting
+                            ChangeTargetState(attacker, AIState.Attack, selectedTargetingParams.Priority * 2);
+                            SelectTarget(attacker.AiTarget);
+                            return;
+                        }
                     }
                     float sqrDist = Vector2.DistanceSquared(WorldPosition, SelectedAiTarget.WorldPosition);
                     float reactDist = selectedTargetingParams != null && selectedTargetingParams.ReactDistance > 0 ? selectedTargetingParams.ReactDistance : GetPerceivingRange(SelectedAiTarget);
@@ -446,6 +529,64 @@ namespace Barotrauma
                         UpdateIdle(deltaTime);
                     }
                     break;
+                case AIState.Observe:
+                    if (SelectedAiTarget == null || SelectedAiTarget.Entity == null || SelectedAiTarget.Entity.Removed)
+                    {
+                        State = AIState.Idle;
+                        return;
+                    }
+                    run = false;
+                    sqrDist = Vector2.DistanceSquared(WorldPosition, SelectedAiTarget.WorldPosition);
+                    reactDist = selectedTargetingParams != null && selectedTargetingParams.ReactDistance > 0 ? selectedTargetingParams.ReactDistance : GetPerceivingRange(SelectedAiTarget);
+                    float halfReactDist = reactDist / 2;
+                    float attackDist = selectedTargetingParams != null && selectedTargetingParams.AttackDistance > 0 ? selectedTargetingParams.AttackDistance : halfReactDist;
+                    if (sqrDist > Math.Pow(reactDist, 2))
+                    {
+                        // Too far to react
+                        UpdateIdle(deltaTime);
+                    }
+                    else if (sqrDist < Math.Pow(attackDist + movementMargin, 2))
+                    {
+                        movementMargin = attackDist;
+                        SteeringManager.Reset();
+                        if (Character.AnimController.InWater)
+                        {
+                            useSteeringLengthAsMovementSpeed = true;
+                            Vector2 dir = Vector2.Normalize(SelectedAiTarget.WorldPosition - Character.WorldPosition);
+                            if (sqrDist < Math.Pow(attackDist * 0.75f, 2))
+                            {
+                                // Keep the distance, if too close
+                                dir = -dir;
+                                useSteeringLengthAsMovementSpeed = false;
+                                Reverse = true;
+                                run = true;
+                            }
+                            else
+                            {
+                                Reverse = false;
+                            }
+                            SteeringManager.SteeringManual(deltaTime, dir * 0.2f);
+                        }
+                        else
+                        {
+                            // TODO: doesn't work right here
+                            FaceTarget(SelectedAiTarget.Entity);
+                        }
+                        observeTimer -= deltaTime;
+                        if (observeTimer < 0)
+                        {
+                            IgnoreTarget(SelectedAiTarget);
+                            State = AIState.Idle;
+                            ResetAITarget();
+                        }
+                    }
+                    else
+                    {
+                        run = sqrDist > Math.Pow(attackDist * 2, 2);
+                        movementMargin = MathHelper.Clamp(movementMargin -= deltaTime, 0, attackDist);
+                        UpdateFollow(deltaTime);
+                    }
+                    break;
                 default:
                     throw new NotImplementedException();
             }
@@ -465,7 +606,8 @@ namespace Barotrauma
             SteerInsideLevel(deltaTime);
             float speed = Character.AnimController.GetCurrentSpeed(run && Character.CanRun);
             steeringManager.Update(speed);
-            Character.AnimController.TargetMovement = Character.ApplyMovementLimits(Steering, State == AIState.Idle && Character.AnimController.InWater ? Steering.Length() : speed);
+            float targetMovement =  useSteeringLengthAsMovementSpeed ? Steering.Length() : speed;
+            Character.AnimController.TargetMovement = Character.ApplyMovementLimits(Steering, targetMovement);
             if (Character.CurrentHull != null && Character.AnimController.InWater)
             {
                 // Halve the swimming speed inside the sub
@@ -601,7 +743,7 @@ namespace Barotrauma
                 {
                     // Steer away from the target if in the same room
                     Vector2 escapeDir = Vector2.Normalize(SelectedAiTarget != null ? WorldPosition - SelectedAiTarget.WorldPosition : Character.AnimController.TargetMovement);
-                    if (!MathUtils.IsValid(escapeDir)) escapeDir = Vector2.UnitY;
+                    if (!MathUtils.IsValid(escapeDir)) { escapeDir = Vector2.UnitY; }
                     SteeringManager.SteeringManual(deltaTime, escapeDir);
                 }
                 else if (pathSteering != null)
@@ -922,7 +1064,7 @@ namespace Barotrauma
             }
             if (!Character.AnimController.SimplePhysicsEnabled && SelectedAiTarget.Entity.Submarine != null && Character.Submarine == null && (!canAttackDoors || !canAttackWalls || !AIParams.TargetOuterWalls))
             {
-                if (Vector2.DistanceSquared(Character.WorldPosition, attackWorldPos) < 2000 * 2000)
+                if (wallTarget == null && Vector2.DistanceSquared(Character.WorldPosition, attackWorldPos) < 2000 * 2000)
                 {
                     // Check that we are not bumping into a door or a wall
                     Vector2 rayStart = SimPosition;
@@ -1193,7 +1335,7 @@ namespace Barotrauma
             }
             if (AIParams.RandomAttack)
             {
-                selectedLimb = ToolBox.SelectWeightedRandom(attackLimbs, weights, Rand.RandSync.Server);
+                selectedLimb = ToolBox.SelectWeightedRandom(attackLimbs, weights, Rand.RandSync.Unsynced);
                 attackLimbs.Clear();
                 weights.Clear();
             }
@@ -1268,7 +1410,7 @@ namespace Barotrauma
                     LatchOntoAI?.SetAttachTarget(wall.Submarine.PhysicsBody.FarseerBody, wall.Submarine, ConvertUnits.ToSimUnits(sectionPos), attachTargetNormal);
                     if (Character.AnimController.CanEnterSubmarine || !wall.SectionBodyDisabled(sectionIndex) && !IsWallDisabled(wall))
                     {
-                        if (AIParams.TargetOuterWalls || wall.prefab.Tags.Contains("inner"))
+                        if (AIParams.TargetOuterWalls || wall.prefab.Tags.Contains("inner") || wall.Submarine != null && wall.Submarine == Character.Submarine)
                         {
                             wallTarget = new WallTarget(sectionPos, wall, sectionIndex);
                         }
@@ -1309,11 +1451,12 @@ namespace Barotrauma
             bool wasLatched = IsLatchedOnSub;
             Character.AnimController.ReleaseStuckLimbs();
             LatchOntoAI?.DeattachFromBody(cooldown: 1);
-            if (attacker == null || attacker.AiTarget == null) { return; }
+            if (attacker == null || attacker.AiTarget == null || attacker.Removed || attacker.IsDead) { return; }
             bool isFriendly = IsFriendly(Character, attacker);
             if (wasLatched)
             {
-                avoidTimer = avoidTime * Rand.Range(0.75f, 1.25f);
+                State = AIState.Escape;
+                avoidTimer = AIParams.AvoidTime * Rand.Range(0.75f, 1.25f);
                 if (!isFriendly)
                 {
                     SelectTarget(attacker.AiTarget);
@@ -1386,7 +1529,7 @@ namespace Barotrauma
             }
 
             AITargetMemory targetMemory = GetTargetMemory(attacker.AiTarget, true);
-            targetMemory.Priority += GetRelativeDamage(attackResult.Damage, Character.Vitality) * AggressionHurt;
+            targetMemory.Priority += GetRelativeDamage(attackResult.Damage, Character.Vitality) * AIParams.AggressionHurt;
 
             // Only allow to react once. Otherwise would attack the target with only a fraction of a cooldown
             bool retaliate = !isFriendly && SelectedAiTarget != attacker.AiTarget && attacker.Submarine == Character.Submarine;
@@ -1411,7 +1554,14 @@ namespace Barotrauma
             }
             else if (avoidGunFire)
             {
-                avoidTimer = avoidTime * Rand.Range(0.75f, 1.25f);
+                State = AIState.Escape;
+                avoidTimer = AIParams.AvoidTime * Rand.Range(0.75f, 1.25f);
+                SelectTarget(attacker.AiTarget);
+            }
+            if (Character.HealthPercentage <= FleeHealthThreshold)
+            {
+                State = AIState.Flee;
+                avoidTimer = AIParams.MinFleeTime * Rand.Range(0.75f, 1.25f);
                 SelectTarget(attacker.AiTarget);
             }
         }
@@ -1441,7 +1591,7 @@ namespace Barotrauma
                     if (damageTarget.Health > 0)
                     {
                         // Managed to hit a living/non-destroyed target. Increase the priority more if the target is low in health -> dies easily/soon
-                        selectedTargetMemory.Priority += GetRelativeDamage(attackResult.Damage, damageTarget.Health) * AggressionGreed;
+                        selectedTargetMemory.Priority += GetRelativeDamage(attackResult.Damage, damageTarget.Health) * AIParams.AggressionGreed;
                     }
                     else
                     {
@@ -1484,7 +1634,7 @@ namespace Barotrauma
                 State = AIState.Idle;
                 return;
             }
-            if (SelectedAiTarget.Entity is Character target)
+            if (SelectedAiTarget.Entity is Character || SelectedAiTarget.Entity is Item)
             {
                 Limb mouthLimb = Character.AnimController.GetLimb(LimbType.Head);
                 if (mouthLimb == null)
@@ -1494,12 +1644,38 @@ namespace Barotrauma
                     return;
                 }
                 Vector2 mouthPos = Character.AnimController.SimplePhysicsEnabled ? SimPosition : Character.AnimController.GetMouthPosition().Value;
-                Vector2 attackSimPosition = Character.GetRelativeSimPosition(target);
+                Vector2 attackSimPosition = Character.GetRelativeSimPosition(SelectedAiTarget.Entity);
                 Vector2 limbDiff = attackSimPosition - mouthPos;
                 float extent = Math.Max(mouthLimb.body.GetMaxExtent(), 2);
                 if (limbDiff.LengthSquared() < extent * extent)
                 {
-                    Character.SelectCharacter(target);
+                    if (SelectedAiTarget.Entity is Character targetCharacter)
+                    {
+                        Character.SelectCharacter(targetCharacter);
+                    }
+                    else if (SelectedAiTarget.Entity is Item item)
+                    {
+                        if (!item.Removed && item.body != null)
+                        {
+                            float itemBodyExtent = item.body.GetMaxExtent() * 2;
+                            if (Math.Abs(limbDiff.X) < itemBodyExtent &&
+                                Math.Abs(limbDiff.Y) < Character.AnimController.Collider.GetMaxExtent() + Character.AnimController.ColliderHeightFromFloor)
+                            {
+                                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);
+                                }
+                            }
+                        }
+                    }
                     steeringManager.SteeringManual(deltaTime, Vector2.Normalize(limbDiff) * 3);
                     Character.AnimController.Collider.ApplyForce(limbDiff * mouthLimb.Mass * 50.0f, mouthPos);
                 }
@@ -1529,15 +1705,40 @@ namespace Barotrauma
                 State = AIState.Idle;
                 return;
             }
-            Vector2 dir = Vector2.Normalize(SelectedAiTarget.Entity.WorldPosition - Character.WorldPosition);
-            if (!MathUtils.IsValid(dir))
+            if (Character.CurrentHull != null && PathSteering != null)
             {
-                return;
+                // Inside
+                Character targetCharacter = SelectedAiTarget.Entity as Character;
+                if ((Character.AnimController.InWater || !Character.AnimController.CanWalk) &&
+                    (targetCharacter != null && VisibleHulls.Contains(targetCharacter.CurrentHull) || Character.CanSeeTarget(SelectedAiTarget.Entity)))
+                {
+                    // Steer towards the target if in the same room and swimming
+                    Vector2 dir = Vector2.Normalize(SelectedAiTarget.Entity.WorldPosition - Character.WorldPosition);
+                    if (MathUtils.IsValid(dir))
+                    {
+                        SteeringManager.SteeringManual(deltaTime, dir);
+                    }
+                }
+                else
+                {
+                    // Use path finding
+                    SteeringManager.SteeringSeek(Character.GetRelativeSimPosition(SelectedAiTarget.Entity), 2);
+                    if (!PathSteering.IsPathDirty && PathSteering.CurrentPath.Unreachable)
+                    {
+                        // Can't reach
+                        State = AIState.Idle;
+                        return;
+                    }
+                }
             }
-            steeringManager.SteeringManual(deltaTime, dir);
-            if (Character.AnimController.InWater)
+            else
             {
-                SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 15);
+                // Outside
+                SteeringManager.SteeringSeek(Character.GetRelativeSimPosition(SelectedAiTarget.Entity), 5);
+                if (Character.AnimController.InWater)
+                {
+                    SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 15);
+                }
             }
         }
 
@@ -1557,6 +1758,7 @@ namespace Barotrauma
             foreach (AITarget aiTarget in AITarget.List)
             {
                 if (!aiTarget.Enabled) { continue; }
+                if (aiTarget.Entity == null) { continue; }
                 if (ignoredTargets.Contains(aiTarget)) { continue; }
                 if (Level.Loaded != null && aiTarget.WorldPosition.Y > Level.Loaded.Size.Y)
                 {
@@ -1579,6 +1781,10 @@ namespace Barotrauma
                     {
                         targetingTag = "dead";
                     }
+                    else if (PetBehavior != null && aiTarget.Entity == PetBehavior.Owner)
+                    {
+                        targetingTag = "owner";
+                    }
                     else if (AIParams.TryGetTarget(targetCharacter.SpeciesName, out CharacterParams.TargetParams tP))
                     {
                         targetingTag = tP.Tag;
@@ -1626,7 +1832,7 @@ namespace Barotrauma
                         }
                     }
                 }
-                else if (aiTarget.Entity != null)
+                else
                 {
                     // Ignore all structures and items inside wrecks
                     if (aiTarget.Entity.Submarine != null && aiTarget.Entity.Submarine.Info.IsWreck) { continue; }
@@ -1784,8 +1990,10 @@ namespace Barotrauma
                         {
                             targetingTag = "door";
                         }
-                        if (door.Item.Submarine == null) { continue;}
+                        if (door.Item.Submarine == null) { continue; }
                         bool isOutdoor = door.LinkedGap?.FlowTargetHull != null && !door.LinkedGap.IsRoomToRoom;
+                        // Ignore inner doors when outside
+                        if (character.CurrentHull == null && !isOutdoor) { continue; }
                         bool isOpen = door.IsOpen || door.IsBroken;
                         if (!isOpen && !canAttackDoors || (isOutdoor && !AIParams.TargetOuterWalls))
                         {
@@ -1795,26 +2003,22 @@ namespace Barotrauma
                         if (isOpen && (!Character.AnimController.CanEnterSubmarine || !AggressiveBoarding))
                         {
                             // Ignore broken and open doors
-                            // Aggressive boarders don't ignore open doors, because they use them for get in.
+                            // Aggressive boarders don't ignore open doors, because they use them for getting in.
                             continue;
                         }
                         if (AggressiveBoarding)
                         {
                             // Increase the priority if the character is outside and the door is from outside to inside
-                            if (character.CurrentHull == null && isOutdoor)
+                            if (character.CurrentHull == null)
                             {
                                 valueModifier *= isOpen ? 5 : 1;
                             }
                             else
                             {
-                                // Inside
+                                // Inside -> ignore open doors and outer doors
                                 valueModifier *= isOpen || isOutdoor ? 0 : 1;
                             }
                         }
-                        else if (character.CurrentHull == null)
-                        {
-                            valueModifier = isOutdoor ? 1 : 0;
-                        }
                     }
                     else if (aiTarget.Entity is IDamageable targetDamageable && targetDamageable.Health <= 0.0f)
                     {
@@ -1823,8 +2027,20 @@ namespace Barotrauma
                 }
 
                 if (targetingTag == null) { continue; }
-                var targetParams = GetTarget(targetingTag);
+                var targetParams = GetTargetParams(targetingTag);
                 if (targetParams == null) { continue; }
+                if (targetParams.State == AIState.Observe || targetParams.State == AIState.Eat)
+                {
+                    if (targetCharacter != null && targetCharacter.Submarine != Character.Submarine)
+                    {
+                        // Don't allow to target characters that are inside a different submarine / outside when we are inside.
+                        continue;
+                    }
+                }
+                if (aiTarget.Entity is Item targetItem && targetParams.IgnoreContained && targetItem.ParentInventory != null)
+                {
+                    continue;
+                }
                 valueModifier *= targetParams.Priority;
 
                 if (valueModifier == 0.0f) { continue; }
@@ -1894,6 +2110,17 @@ namespace Barotrauma
                     }
                     if (targetCharacter != null)
                     {
+                        if (Character.CurrentHull != null && targetCharacter.CurrentHull != Character.CurrentHull)
+                        {
+                            if (targetParams.State == AIState.Follow || targetParams.State == AIState.Protect || targetParams.State == AIState.Observe)
+                            {
+                                // Ignore targets that cannot see
+                                if (!VisibleHulls.Contains(targetCharacter.CurrentHull))
+                                {
+                                    continue;
+                                }
+                            }
+                        }
                         if (targetCharacter.Submarine != Character.Submarine)
                         {
                             if (targetCharacter.Submarine != null)
@@ -1939,7 +2166,7 @@ namespace Barotrauma
                     newTarget = aiTarget;
                     selectedTargetMemory = targetMemory;
                     targetValue = valueModifier;
-                    targetingParams = GetTarget(targetingTag);
+                    targetingParams = GetTargetParams(targetingTag);
                 }
             }
 
@@ -1999,7 +2226,7 @@ namespace Barotrauma
                 {
                     _selectedAiTarget = null;
                 }
-                else if (CanPerceive(_selectedAiTarget, distSquared: Vector2.DistanceSquared(Character.WorldPosition, _selectedAiTarget.WorldPosition)))
+                else if (CanPerceive(_selectedAiTarget))
                 {
                     var memory = GetTargetMemory(_selectedAiTarget, false);
                     if (memory != null)
@@ -2040,7 +2267,7 @@ namespace Barotrauma
             removals.ForEach(r => targetMemories.Remove(r));
         }
 
-        private readonly float targetIgnoreTime = 5;
+        private readonly float targetIgnoreTime = 10;
         private float targetIgnoreTimer;
         private readonly HashSet<AITarget> ignoredTargets = new HashSet<AITarget>();
         public void IgnoreTarget(AITarget target)
@@ -2168,6 +2395,17 @@ namespace Barotrauma
         }
         #endregion
 
+        protected override void OnTargetChanged(AITarget previousTarget, AITarget newTarget)
+        {
+            base.OnTargetChanged(previousTarget, newTarget);
+            if (newTarget == null) { return; }
+            var targetParams = GetTargetParams(newTarget);
+            if (targetParams != null)
+            {
+                observeTimer = targetParams.Timer * Rand.Range(0.75f, 1.25f);
+            }
+        }
+
         protected override void OnStateChanged(AIState from, AIState to)
         {
             LatchOntoAI?.DeattachFromBody();
@@ -2189,13 +2427,17 @@ namespace Barotrauma
 
         private bool CanPerceive(AITarget target, float dist = -1, float distSquared = -1)
         {
-            if (distSquared > -1)
+            if (dist > 0)
             {
-                return distSquared <= MathUtils.Pow(target.SightRange * Sight, 2) || distSquared <=  MathUtils.Pow(target.SoundRange * Hearing, 2);
+                return dist <= target.SightRange * Sight || dist <= target.SoundRange * Hearing;
             }
             else
             {
-                return dist <= target.SightRange * Sight || dist <= target.SoundRange * Hearing;
+                if (distSquared < 0)
+                {
+                    distSquared = Vector2.DistanceSquared(Character.WorldPosition, target.WorldPosition);
+                }
+                return distSquared <= MathUtils.Pow(target.SightRange * Sight, 2) || distSquared <= MathUtils.Pow(target.SoundRange * Hearing, 2);
             }
         }
 

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/HumanAIController.cs

@@ -35,6 +35,14 @@ namespace Barotrauma
         public readonly HashSet<Hull> UnsafeHulls = new HashSet<Hull>();
         public readonly List<Item> IgnoredItems = new List<Item>();
 
+        private float respondToAttackTimer;
+        private const float RespondToAttackInterval = 1.0f;
+
+        /// <summary>
+        /// List of previous attacks done to this character
+        /// </summary>
+        private readonly Dictionary<Character, AttackResult> previousAttackResults = new Dictionary<Character, AttackResult>();
+
         private class HullSafety
         {
             public float safety;
@@ -138,6 +146,17 @@ namespace Barotrauma
             }
             if (isIncapacitated) { return; }
 
+            respondToAttackTimer -= deltaTime;
+            if (respondToAttackTimer <= 0.0f)
+            {
+                foreach (var previousAttackResult in previousAttackResults)
+                {
+                    RespondToAttack(previousAttackResult.Key, previousAttackResult.Value);
+                }
+                previousAttackResults.Clear();
+                respondToAttackTimer = RespondToAttackInterval;
+            }
+
             base.Update(deltaTime);
 
             foreach (var values in knownHulls)
@@ -316,6 +335,7 @@ namespace Barotrauma
         {
             if (Character.LockHands) { return; }
             if (ObjectiveManager.CurrentObjective == null) { return; }
+            if (Character.CurrentHull == null) { return; }
             bool oxygenLow = !Character.AnimController.HeadInWater && Character.OxygenAvailable < CharacterHealth.LowOxygenThreshold;
             bool isCarrying = ObjectiveManager.HasActiveObjective<AIObjectiveContainItem>() || ObjectiveManager.HasActiveObjective<AIObjectiveDecontainItem>();
 
@@ -349,7 +369,9 @@ 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
                         || ObjectiveManager.IsCurrentObjective<AIObjectiveFindSafety>()
+                        || ObjectiveManager.CurrentOrder is AIObjectiveGoTo goTo && goTo.Target == Character   // wait order
                         || ObjectiveManager.CurrentObjective.GetSubObjectivesRecursive(true).Any(o => o.KeepDivingGearOn);
                     if (oxygenLow && Character.CurrentHull.Oxygen > 0)
                     {
@@ -425,12 +447,14 @@ namespace Barotrauma
                                     {
                                         var decontainObjective = new AIObjectiveDecontainItem(Character, divingSuit, ObjectiveManager, targetContainer: targetContainer.GetComponent<ItemContainer>())
                                         {
-                                            DropIfFailsToContain = false
+                                            DropIfFails = false
                                         };
                                         decontainObjective.Abandoned += () =>
                                         {
+                                            ReequipUnequipped();
                                             IgnoredItems.Add(targetContainer);
                                         };
+                                        decontainObjective.Completed += () => ReequipUnequipped();
                                         ObjectiveManager.CurrentObjective.AddSubObjective(decontainObjective, addFirst: true);
                                         return;
                                     }
@@ -451,7 +475,7 @@ namespace Barotrauma
                             {
                                 if (!mask.AllowedSlots.Contains(InvSlotType.Any) || !Character.Inventory.TryPutItem(mask, Character, new List<InvSlotType>() { InvSlotType.Any }))
                                 {
-                                    if (oxygenLow || ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
+                                    if (ObjectiveManager.GetCurrentPriority() >= AIObjectiveManager.RunPriority)
                                     {
                                         mask.Drop(Character);
                                     }
@@ -465,7 +489,12 @@ namespace Barotrauma
                                             if (targetContainer != null)
                                             {
                                                 var decontainObjective = new AIObjectiveDecontainItem(Character, mask, ObjectiveManager, targetContainer: targetContainer.GetComponent<ItemContainer>());
-                                                decontainObjective.Abandoned += () => IgnoredItems.Add(targetContainer);
+                                                decontainObjective.Abandoned += () =>
+                                                {
+                                                    ReequipUnequipped();
+                                                    IgnoredItems.Add(targetContainer);
+                                                };
+                                                decontainObjective.Completed += () => ReequipUnequipped();
                                                 ObjectiveManager.CurrentObjective.AddSubObjective(decontainObjective, addFirst: true);
                                                 return;
                                             }
@@ -476,6 +505,10 @@ namespace Barotrauma
                                         }
                                     }
                                 }
+                                else
+                                {
+                                    ReequipUnequipped();
+                                }
                             }
                         }
                     }
@@ -504,7 +537,11 @@ namespace Barotrauma
                                 if (targetContainer != null)
                                 {
                                     var decontainObjective = new AIObjectiveDecontainItem(Character, item, ObjectiveManager, targetContainer: targetContainer.GetComponent<ItemContainer>());
-                                    decontainObjective.Abandoned += () => IgnoredItems.Add(targetContainer);
+                                    decontainObjective.Abandoned += () =>
+                                    {
+                                        ReequipUnequipped();
+                                        IgnoredItems.Add(targetContainer);
+                                    };
                                     ObjectiveManager.CurrentObjective.AddSubObjective(decontainObjective, addFirst: true);
                                     return;
                                 }
@@ -519,6 +556,18 @@ namespace Barotrauma
             }
         }
 
+        public void ReequipUnequipped()
+        {
+            foreach (var item in unequippedItems)
+            {
+                if (item != null && !item.Removed && Character.HasItem(item))
+                {
+                    TakeItem(item, Character.Inventory, equip: true, dropOtherIfCannotMove: true, allowSwapping: true, storeUnequipped: false);
+                }
+            }
+            unequippedItems.Clear();
+        }
+
         private enum FindItemState
         {
             None,
@@ -528,10 +577,13 @@ namespace Barotrauma
         }
         private FindItemState findItemState;
         private int itemIndex;
-        public bool FindSuitableContainer(Item containableItem, out Item suitableContainer)
+
+        public bool FindSuitableContainer(Item containableItem, out Item suitableContainer) => FindSuitableContainer(Character, containableItem, IgnoredItems, ref itemIndex, out suitableContainer);
+
+        public static bool FindSuitableContainer(Character character, Item containableItem, List<Item> ignoredItems, ref int itemIndex, out Item suitableContainer)
         {
             suitableContainer = null;
-            if (Character.FindItem(ref itemIndex, out Item targetContainer, ignoredItems: IgnoredItems, customPriorityFunction: i =>
+            if (character.FindItem(ref itemIndex, out Item targetContainer, ignoredItems: ignoredItems, customPriorityFunction: i =>
             {
                 var container = i.GetComponent<ItemContainer>();
                 if (container == null) { return 0; }
@@ -663,6 +715,17 @@ namespace Barotrauma
             }
         }
 
+        public static void ReportProblem(Character reporter, Order order)
+        {
+            if (reporter == null || order == null) { return; }
+            var visibleHulls = new List<Hull>(reporter.GetVisibleHulls());
+            foreach (var hull in visibleHulls)
+            {
+                PropagateHullSafety(reporter, hull);
+                RefreshTargets(reporter, order, hull);
+            }
+        }
+
         private void UpdateSpeaking()
         {
             if (Character.Oxygen < 20.0f)
@@ -683,6 +746,38 @@ namespace Barotrauma
 
         public override void OnAttacked(Character attacker, AttackResult attackResult)
         {
+            if (Character.IsDead) { return; }
+            if (attacker == null || Character.IsPlayer)
+            {
+                // The player characters need to "respond" to the attack always, because the update loop doesn't run for them.
+                // Otherwise other NPCs totally ignore when player characters are attacked.
+                RespondToAttack(attacker, attackResult);
+                return;
+            }
+            if (previousAttackResults.ContainsKey(attacker))
+            {
+                foreach (Affliction newAffliction in attackResult.Afflictions)
+                {
+                    var matchingAffliction = previousAttackResults[attacker].Afflictions.Find(a => a.Prefab == newAffliction.Prefab && a.Source == newAffliction.Source);
+                    if (matchingAffliction == null)
+                    {
+                        previousAttackResults[attacker].Afflictions.Add(newAffliction);
+                    }
+                    else
+                    {
+                        matchingAffliction.Strength += newAffliction.Strength;
+                    }
+                }
+                previousAttackResults[attacker] = new AttackResult(previousAttackResults[attacker].Afflictions, previousAttackResults[attacker].HitLimb);
+            }
+            else
+            {
+                previousAttackResults.Add(attacker, attackResult);
+            }
+        }
+
+        private void RespondToAttack(Character attacker, AttackResult attackResult)
+        { 
             // excluding poisons etc
             float realDamage = attackResult.Damage;
             // including poisons etc
@@ -691,7 +786,7 @@ namespace Barotrauma
             {
                 totalDamage -= affliction.Prefab.KarmaChangeOnApplied * affliction.Strength;
             }
-            if (totalDamage <= 0) { return; }
+            if (totalDamage <= 0.01f) { return; }
             if (Character.IsBot)
             {
                 if (attacker != null)
@@ -735,7 +830,7 @@ namespace Barotrauma
                     return;
                 }
                 float cumulativeDamage = GetDamageDoneByAttacker(attacker);
-                if (!Character.IsSecurity && attacker.IsBot && !attacker.IsInstigator)
+                if (!Character.IsSecurity && attacker.IsBot && Character.CombatAction == null)
                 {
                     if (cumulativeDamage > 1)
                     {
@@ -834,7 +929,17 @@ namespace Barotrauma
                 }
                 else
                 {
-                    if (attacker.TeamID == Character.TeamType.FriendlyNPC)
+                    // If there are any enemies around, just ignore the friendly fire
+                    if (Character.CharacterList.Any(ch => ch.Submarine == Character.Submarine && !ch.Removed && !ch.IsDead && !ch.IsIncapacitated && !IsFriendly(ch) && VisibleHulls.Contains(ch.CurrentHull)))
+                    {
+                        return AIObjectiveCombat.CombatMode.None;
+                    }
+                    if (Character.IsInstigator && attacker.IsPlayer)
+                    {
+                        // The guards don't react when the player attacks instigators.
+                        return c.IsSecurity ? AIObjectiveCombat.CombatMode.None : (Character.CombatAction != null ? Character.CombatAction.WitnessReaction : AIObjectiveCombat.CombatMode.Retreat);
+                    }
+                    else if (attacker.TeamID == Character.TeamType.FriendlyNPC)
                     {
                         if (c.IsSecurity)
                         {
@@ -847,11 +952,7 @@ namespace Barotrauma
                     }
                     else
                     {
-                        if (Character.IsInstigator)
-                        {
-                            return c.IsSecurity ? AIObjectiveCombat.CombatMode.Arrest : AIObjectiveCombat.CombatMode.Retreat;
-                        }
-                        else if (cumulativeDamage > dmgThreshold)
+                        if (cumulativeDamage > dmgThreshold)
                         {
                             if (c.IsSecurity)
                             {
@@ -1006,39 +1107,54 @@ namespace Barotrauma
             return true;
         }
 
-        public bool TryToMoveItem(Item item, Inventory targetInventory, bool dropIfCannotMove = true)
+        private readonly HashSet<Item> unequippedItems = new HashSet<Item>();
+        public bool TakeItem(Item item, Inventory targetInventory, bool equip, bool dropOtherIfCannotMove = true, bool allowSwapping = false, bool storeUnequipped = false)
         {
             var pickable = item.GetComponent<Pickable>();
-            if (pickable == null) { return false; }
-            int targetSlot = -1;
-            //check if all the slots required by the item are free
-            foreach (InvSlotType slots in pickable.AllowedSlots)
+            if (item.ParentInventory is ItemInventory itemInventory)
             {
-                if (slots.HasFlag(InvSlotType.Any)) { continue; }
-                for (int i = 0; i < targetInventory.Items.Length; i++)
+                if (!itemInventory.Container.HasRequiredItems(Character, addMessage: false)) { return false; }
+            }
+            if (equip)
+            {
+                int targetSlot = -1;
+                //check if all the slots required by the item are free
+                foreach (InvSlotType slots in pickable.AllowedSlots)
                 {
-                    if (targetInventory is CharacterInventory characterInventory)
+                    if (slots.HasFlag(InvSlotType.Any)) { continue; }
+                    for (int i = 0; i < targetInventory.Items.Length; i++)
                     {
-                        //slot not needed by the item, continue
-                        if (!slots.HasFlag(characterInventory.SlotTypes[i])) { continue; }
-                    }
-                    targetSlot = i;
-                    //slot free, continue
-                    var otherItem = targetInventory.Items[i];
-                    if (otherItem == null) { continue; }
-                    //try to move the existing item to LimbSlot.Any and continue if successful
-                    if (otherItem.AllowedSlots.Contains(InvSlotType.Any) && targetInventory.TryPutItem(otherItem, Character, new List<InvSlotType>() { InvSlotType.Any }))
-                    {
-                        continue;
-                    }
-                    if (dropIfCannotMove)
-                    {
-                        //if everything else fails, simply drop the existing item
-                        otherItem.Drop(Character);
+                        if (targetInventory is CharacterInventory characterInventory)
+                        {
+                            //slot not needed by the item, continue
+                            if (!slots.HasFlag(characterInventory.SlotTypes[i])) { continue; }
+                        }
+                        targetSlot = i;
+                        //slot free, continue
+                        var otherItem = targetInventory.Items[i];
+                        if (otherItem == null) { continue; }
+                        //try to move the existing item to LimbSlot.Any and continue if successful
+                        if (otherItem.AllowedSlots.Contains(InvSlotType.Any) && targetInventory.TryPutItem(otherItem, Character, CharacterInventory.anySlot))
+                        {
+                            if (storeUnequipped && targetInventory.Owner == Character)
+                            {
+                                unequippedItems.Add(otherItem);
+                            }
+                            continue;
+                        }
+                        if (dropOtherIfCannotMove)
+                        {
+                            //if everything else fails, simply drop the existing item
+                            otherItem.Drop(Character);
+                        }
                     }
                 }
+                return targetInventory.TryPutItem(item, targetSlot, allowSwapping, allowCombine: false, Character);
+            }
+            else
+            {
+                return targetInventory.TryPutItem(item, Character, CharacterInventory.anySlot);
             }
-            return targetInventory.TryPutItem(item, targetSlot, false, false, Character);
         }
 
         public static bool NeedsDivingGear(Hull hull, out bool needsSuit)
@@ -1107,7 +1223,7 @@ namespace Barotrauma
                     }
                     //if (!otherCharacter.IsFacing(thief.WorldPosition)) { continue; }
                     if (!otherCharacter.CanSeeCharacter(thief)) { continue; }
-                    if (!someoneSpoke)
+                    if (!someoneSpoke && !character.IsIncapacitated && character.Stun <= 0.0f)
                     {
                         if (!item.StolenDuringRound && GameMain.GameSession?.Campaign?.Map?.CurrentLocation != null)
                         {
@@ -1306,7 +1422,7 @@ namespace Barotrauma
                 // Use the cached visible hulls
                 visibleHulls = VisibleHulls;
             }
-            bool ignoreFire = objectiveManager.HasActiveObjective<AIObjectiveExtinguishFire>();
+            bool ignoreFire = objectiveManager.CurrentOrder is AIObjectiveExtinguishFires extinguishOrder && extinguishOrder.Priority > 0 || objectiveManager.HasActiveObjective<AIObjectiveExtinguishFire>();
             bool ignoreWater = HasDivingSuit(character);
             bool ignoreOxygen = ignoreWater || HasDivingMask(character);
             bool ignoreEnemies = ObjectiveManager.IsCurrentObjective<AIObjectiveFightIntruders>();
@@ -1391,13 +1507,10 @@ namespace Barotrauma
             return hullSafety.safety;
         }
 
-        public void FaceTarget(ISpatialEntity target) => Character.AnimController.TargetDir = target.WorldPosition.X > Character.WorldPosition.X ? Direction.Right : Direction.Left;
-
         public static bool IsFriendly(Character me, Character other, bool onlySameTeam = false)
         {
             bool sameTeam = me.TeamID == other.TeamID;
-            // Only enemies are in the Team "None"
-            bool friendlyTeam = me.TeamID != Character.TeamType.None && other.TeamID != Character.TeamType.None;
+            bool friendlyTeam = IsOnFriendlyTeam(GameMain.GameSession?.GameMode, me, other);
             bool teamGood = sameTeam || friendlyTeam && !onlySameTeam;
             if (!teamGood) { return false; }
             bool speciesGood = other.SpeciesName == me.SpeciesName || other.Params.CompareGroup(me.Params.Group);
@@ -1413,6 +1526,18 @@ namespace Barotrauma
             return true;
         }
 
+        private static bool IsOnFriendlyTeam(GameMode mode, Character me, Character other)
+        {
+            // Only enemies are in the Team "None"
+            bool friendlyTeam = me.TeamID != Character.TeamType.None && other.TeamID != Character.TeamType.None;
+            // When playing a combat mission, we need to be on the same team to be friendlies
+            if (friendlyTeam && mode is MissionMode mm && mm.Mission is CombatMission)
+            {
+                friendlyTeam = me.TeamID == other.TeamID;
+            }
+            return friendlyTeam;
+        }
+
         public static bool IsActive(Character other) => other != null && !other.Removed && !other.IsDead && !other.IsUnconscious;
 
         public static bool IsTrueForAllCrewMembers(Character character, Func<HumanAIController, bool> predicate)

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/IndoorsSteeringManager.cs

@@ -190,14 +190,45 @@ 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;
+                    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)
                     {
@@ -343,7 +374,7 @@ namespace Barotrauma
                 }
                 return diff;
             }
-            else if (!canClimb || character.AnimController.InWater)
+            else if (character.AnimController.InWater)
             {
                 // If the character is underwater, we don't need the ladders anymore
                 if (character.IsClimbing && isDiving)
@@ -370,7 +401,7 @@ namespace Barotrauma
                     }
                 }
             }
-            else if (!IsNextLadderSameAsCurrent)
+            else if (!canClimb || !IsNextLadderSameAsCurrent)
             {
                 // Walking horizontally
                 Vector2 colliderBottom = character.AnimController.GetColliderBottom();
@@ -378,6 +409,8 @@ namespace Barotrauma
                 Vector2 velocity = collider.LinearVelocity;
                 // If the character is smaller than this, it would fail to use the waypoint nodes because they are always too high.
                 float minHeight = 1;
+                // If the character is very thin, without a min value, it would often fail to reach the waypoints, because the horizontal distance is too small.
+                float minWidth = 0.17f;
                 // Cannot use the head position, because not all characters have head or it can be below the total height of the character
                 float characterHeight = Math.Max(colliderSize.Y + character.AnimController.ColliderHeightFromFloor, minHeight);
                 float horizontalDistance = Math.Abs(collider.SimPosition.X - currentPath.CurrentNode.SimPosition.X);
@@ -386,7 +419,7 @@ namespace Barotrauma
                 var door = currentPath.CurrentNode.ConnectedDoor;
                 bool blockedByDoor = door != null && !door.IsOpen && !door.IsBroken;
                 float margin = MathHelper.Lerp(1, 10, MathHelper.Clamp(Math.Abs(velocity.X) / 10, 0, 1));
-                float targetDistance = collider.radius * margin;
+                float targetDistance = Math.Max(collider.radius * margin, minWidth);
                 if (horizontalDistance < targetDistance && isAboveFeet && isNotTooHigh && !blockedByDoor)
                 {
                     currentPath.SkipToNextNode();

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

@@ -15,6 +15,7 @@ namespace Barotrauma
         public virtual bool IgnoreUnsafeHulls => false;
         public virtual bool AbandonWhenCannotCompleteSubjectives => true;
         public virtual bool AllowSubObjectiveSorting => false;
+        public virtual bool ForceOrderPriority => true;
 
         /// <summary>
         /// Can there be multiple objective instaces of the same type?
@@ -34,6 +35,7 @@ namespace Barotrauma
         public virtual bool AllowAutomaticItemUnequipping => false;
         public virtual bool AllowOutsideSubmarine => false;
         public virtual bool AllowInFriendlySubs => false;
+        public virtual bool AllowInAnySub => false;
 
         protected readonly List<AIObjective> subObjectives = new List<AIObjective>();
         private float _cumulatedDevotion;
@@ -198,12 +200,10 @@ namespace Barotrauma
         {
             get 
             { 
-                if (AllowOutsideSubmarine) { return true; }
-                if (character.Submarine == null) { return false; }
-                return 
-                    character.Submarine.TeamID == character.TeamID || 
-                    (AllowInFriendlySubs && character.Submarine.TeamID == Character.TeamType.FriendlyNPC) || 
-                    character.Submarine.DockedTo.Any(sub => sub.TeamID == character.TeamID);
+                if (!AllowOutsideSubmarine && character.Submarine == null) { return false; }
+                if (AllowInAnySub) { return true; }
+                if (AllowInFriendlySubs && character.Submarine.TeamID == Character.TeamType.FriendlyNPC) { return true; }
+                return character.Submarine.TeamID == character.TeamID || character.Submarine.DockedTo.Any(sub => sub.TeamID == character.TeamID);
             }
         }
 
@@ -212,12 +212,14 @@ namespace Barotrauma
         /// </summary>
         public virtual float GetPriority()
         {
+            bool isOrder = objectiveManager.CurrentOrder == this;
             if (!IsAllowed)
             {
                 Priority = 0;
+                Abandon = !isOrder;
                 return Priority;
             }
-            if (objectiveManager.CurrentOrder == this)
+            if (isOrder)
             {
                 Priority = AIObjectiveManager.OrderPriority;
             }
@@ -306,7 +308,7 @@ namespace Barotrauma
                     return true;
                 }
 #if DEBUG
-                DebugConsole.ThrowError("Attempted to add a duplicate subobjective!\n" + Environment.StackTrace);
+                DebugConsole.ThrowError("Attempted to add a duplicate subobjective!\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                 return false;
             }

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

@@ -0,0 +1,124 @@
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveCleanupItem : AIObjective
+    {
+        public override string DebugTag => "cleanup item";
+        public override bool KeepDivingGearOn => true;
+        public override bool AllowAutomaticItemUnequipping => false;
+
+        public readonly Item item;
+        public bool IsPriority { get; set; }
+
+        private readonly List<Item> ignoredContainers = new List<Item>();
+        private AIObjectiveDecontainItem decontainObjective;
+        private int itemIndex = 0;
+
+        public AIObjectiveCleanupItem(Item item, Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            this.item = item;
+        }
+
+        public override float GetPriority()
+        {
+            if (!IsAllowed)
+            {
+                Priority = 0;
+                Abandon = true;
+                return Priority;
+            }
+            else
+            {
+                float distanceFactor = 0.9f;
+                if (!IsPriority && item.CurrentHull != character.CurrentHull)
+                {
+                    float yDist = Math.Abs(character.WorldPosition.Y - item.WorldPosition.Y);
+                    yDist = yDist > 100 ? yDist * 5 : 0;
+                    float dist = Math.Abs(character.WorldPosition.X - item.WorldPosition.X) + yDist;
+                    distanceFactor = MathHelper.Lerp(0.9f, 0, MathUtils.InverseLerp(0, 5000, dist));
+                }
+                bool isSelected = character.HasItem(item);
+                float selectedBonus = isSelected ? 100 - MaxDevotion : 0;
+                float devotion = (CumulatedDevotion + selectedBonus) / 100;
+                float reduction = IsPriority ? 1 : isSelected ? 2 : 3;
+                float max = MathHelper.Min(AIObjectiveManager.OrderPriority - reduction, 90);
+                Priority = MathHelper.Lerp(0, max, MathHelper.Clamp(devotion + (distanceFactor * PriorityModifier), 0, 1));
+            }
+            return Priority;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            // Only continue when the get item sub objectives have been completed.
+            if (subObjectives.Any()) { return; }
+            if (HumanAIController.FindSuitableContainer(character, item, ignoredContainers, ref itemIndex, out Item suitableContainer))
+            {
+                itemIndex = 0;
+                if (suitableContainer != null)
+                {
+                    bool equip = item.HasTag(AIObjectiveFindDivingGear.HEAVY_DIVING_GEAR) || (
+                            item.GetComponent<Wearable>() == null &&
+                            item.AllowedSlots.None(s =>
+                                s == InvSlotType.Card ||
+                                s == InvSlotType.Head ||
+                                s == InvSlotType.Headset ||
+                                s == InvSlotType.InnerClothes ||
+                                s == InvSlotType.OuterClothes));
+                    TryAddSubObjective(ref decontainObjective, () => new AIObjectiveDecontainItem(character, item, objectiveManager, targetContainer: suitableContainer.GetComponent<ItemContainer>())
+                    {
+                        Equip = equip,
+                        DropIfFails = true
+                    }, 
+                    onCompleted: () =>
+                    {
+                        if (equip)
+                        {
+                            HumanAIController.ReequipUnequipped();
+                        }
+                        IsCompleted = true;
+                    }, 
+                    onAbandon: () =>
+                    {
+                        if (equip)
+                        {
+                            HumanAIController.ReequipUnequipped();
+                        }
+                        if (decontainObjective != null && decontainObjective.ContainObjective != null && decontainObjective.ContainObjective.CanBeCompleted)
+                        {
+                            ignoredContainers.Add(suitableContainer);
+                        }
+                        else
+                        {
+                            Abandon = true;
+                        }
+                    });
+                }
+                else
+                {
+                    Abandon = true;
+                }
+            }
+            else
+            {
+                objectiveManager.GetObjective<AIObjectiveIdle>().Wander(deltaTime);
+            }
+        }
+
+        protected override bool Check() => IsCompleted;
+
+        public override void Reset()
+        {
+            base.Reset();
+            ignoredContainers.Clear();
+            itemIndex = 0;
+            decontainObjective = null;
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+using Barotrauma.Items.Components;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveCleanupItems : AIObjectiveLoop<Item>
+    {
+        public override string DebugTag => "cleanup items";
+        public override bool KeepDivingGearOn => true;
+        public override bool AllowAutomaticItemUnequipping => false;
+        public override bool ForceOrderPriority => false;
+
+        public readonly Item prioritizedItem;
+
+        public AIObjectiveCleanupItems(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1, Item prioritizedItem = null)
+            : base(character, objectiveManager, priorityModifier)
+        {
+            this.prioritizedItem = prioritizedItem;
+        }
+
+        protected override float TargetEvaluation() => Targets.Any() ? AIObjectiveManager.RunPriority - 1 : 0;
+
+        protected override bool Filter(Item target)
+        {
+            // If the target was selected as a valid target, we'll have to accept it so that the objective can be completed.
+            // The validity changes when a character picks the item up.
+            if (!IsValidTarget(target, character)) { return Objectives.ContainsKey(target) && IsItemInsideValidSubmarine(target, character); }
+            if (target.CurrentHull.FireSources.Count > 0) { return false; }
+            // Don't repair items in rooms that have enemies inside.
+            if (Character.CharacterList.Any(c => c.CurrentHull == target.CurrentHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c))) { return false; }
+            return true;
+        }
+
+        protected override IEnumerable<Item> GetList() => Item.ItemList;
+
+        protected override AIObjective ObjectiveConstructor(Item item)
+            => new AIObjectiveCleanupItem(item, character, objectiveManager, priorityModifier: PriorityModifier)
+            {
+                IsPriority = prioritizedItem == item
+            };
+
+        protected override void OnObjectiveCompleted(AIObjective objective, Item target)
+            => HumanAIController.RemoveTargets<AIObjectiveCleanupItems, Item>(character, target);
+
+        private static bool IsItemInsideValidSubmarine(Item item, Character character)
+        {
+            if (item.CurrentHull == null) { return false; }
+            if (item.Submarine == null) { return false; }
+            if (item.Submarine.TeamID != character.TeamID) { return false; }
+            if (character.Submarine != null)
+            {
+                if (!character.Submarine.IsConnectedTo(item.Submarine)) { return false; }
+            }
+            return true;
+        }
+
+        public static bool IsValidTarget(Item item, Character character)
+        {
+            if (item == null) { 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; }
+            var wire = item.GetComponent<Wire>();
+            if (wire != null)
+            {
+                if (wire.Connections.Any()) { return false; }
+            }
+            else
+            {
+                var connectionPanel = item.GetComponent<ConnectionPanel>();
+                if (connectionPanel != null && connectionPanel.Connections.Any(c => c.Wires.Any(w => w != null)))
+                {
+                    return false;
+                }
+            }
+            return item.Prefab.PreferredContainers.Any();
+        }
+    }
+}

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

@@ -15,6 +15,7 @@ namespace Barotrauma
         public override bool KeepDivingGearOn => true;
         public override bool IgnoreUnsafeHulls => true;
         public override bool AllowOutsideSubmarine => true;
+        public override bool AllowInAnySub => true;
 
         private readonly CombatMode initialMode;
 
@@ -54,8 +55,8 @@ namespace Barotrauma
                 if (_weaponComponent == null)
                 {
                     _weaponComponent =
-                        Weapon.GetComponent<RangedWeapon>() as ItemComponent ??
-                        Weapon.GetComponent<MeleeWeapon>() as ItemComponent ??
+                        Weapon.GetComponent<RangedWeapon>() ??
+                        Weapon.GetComponent<MeleeWeapon>() ??
                         Weapon.GetComponent<RepairTool>() as ItemComponent;
                 }
                 return _weaponComponent;
@@ -144,6 +145,7 @@ namespace Barotrauma
                 if (Enemy.Submarine == null || (Enemy.Submarine.TeamID != character.TeamID && Enemy.Submarine != character.Submarine))
                 {
                     Priority = 0;
+                    Abandon = true;
                     return Priority;
                 }
             }
@@ -760,11 +762,7 @@ namespace Barotrauma
             if (HumanAIController.HasItem(character, "handlocker", out IEnumerable<Item> matchingItems) && Enemy.Stun > 0 && character.CanInteractWith(Enemy))
             {
                 var handCuffs = matchingItems.First();
-                if (HumanAIController.TryToMoveItem(handCuffs, Enemy.Inventory))
-                {
-                    handCuffs.Equip(Enemy);
-                }
-                else
+                if (!HumanAIController.TakeItem(handCuffs, Enemy.Inventory, equip: true))
                 {
 #if DEBUG
                     DebugConsole.NewMessage($"{character.Name}: Failed to handcuff the target.", Color.Red);
@@ -777,7 +775,7 @@ namespace Barotrauma
                     if (item.StolenDuringRound)
                     {
                         item.Drop(character);
-                        character.Inventory.TryPutItem(item, character, new List<InvSlotType>() { InvSlotType.Any });
+                        character.Inventory.TryPutItem(item, character, CharacterInventory.anySlot);
                     }
                 }
                 character.Speak(TextManager.Get("DialogTargetArrested"), null, 3.0f, "targetarrested", 30.0f);
@@ -885,7 +883,11 @@ namespace Barotrauma
 
         private void Attack(float deltaTime)
         {
-            character.CursorPosition = Enemy.Position;
+            character.CursorPosition = Enemy.WorldPosition;
+            if (character.Submarine != null)
+            {
+                character.CursorPosition -= character.Submarine.Position;
+            }
             visibilityCheckTimer -= deltaTime;
             if (visibilityCheckTimer <= 0.0f)
             {

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

@@ -142,6 +142,7 @@ namespace Barotrauma
                 }
                 else
                 {
+                    // TODO: should we just use GetItem?
                     TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(container.Item, character, objectiveManager, getDivingGearIfNeeded: AllowToFindDivingGear)
                     {
                         DialogueIdentifier = "dialogcannotreachtarget",
@@ -153,27 +154,34 @@ namespace Barotrauma
             }
             else
             {
-                // No matching items in the inventory, try to get an item
-                TryAddSubObjective(ref getItemObjective, () =>
-                    new AIObjectiveGetItem(character, itemIdentifiers, objectiveManager, equip: Equip, checkInventory: checkInventory, spawnItemIfNotFound: spawnItemIfNotFound)
-                    {
-                        GetItemPriority = GetItemPriority,
-                        ignoredContainerIdentifiers = ignoredContainerIdentifiers,
-                        ignoredItems = containedItems,
-                        AllowToFindDivingGear = AllowToFindDivingGear,
-                        AllowDangerousPressure = AllowDangerousPressure,
-                        TargetCondition = ConditionLevel
-                    }, onAbandon: () =>
-                    {
-                        Abandon = true;
-                    }, onCompleted: () =>
-                    {
-                        if (getItemObjective?.TargetItem != null)
+                if (character.Submarine == null)
+                {
+                    Abandon = true;
+                }
+                else
+                {
+                    // No matching items in the inventory, try to get an item
+                    TryAddSubObjective(ref getItemObjective, () =>
+                        new AIObjectiveGetItem(character, itemIdentifiers, objectiveManager, equip: Equip, checkInventory: checkInventory, spawnItemIfNotFound: spawnItemIfNotFound)
                         {
-                            containedItems.Add(getItemObjective.TargetItem);
-                        }
-                        RemoveSubObjective(ref getItemObjective);
-                    });
+                            GetItemPriority = GetItemPriority,
+                            ignoredContainerIdentifiers = ignoredContainerIdentifiers,
+                            ignoredItems = containedItems,
+                            AllowToFindDivingGear = AllowToFindDivingGear,
+                            AllowDangerousPressure = AllowDangerousPressure,
+                            TargetCondition = ConditionLevel
+                        }, onAbandon: () =>
+                        {
+                            Abandon = true;
+                        }, onCompleted: () =>
+                        {
+                            if (getItemObjective?.TargetItem != null)
+                            {
+                                containedItems.Add(getItemObjective.TargetItem);
+                            }
+                            RemoveSubObjective(ref getItemObjective);
+                        });
+                }
             }
         }
 

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

@@ -16,9 +16,12 @@ namespace Barotrauma
         private ItemContainer targetContainer;
         private readonly Item targetItem;
 
-        private AIObjectiveGoTo goToObjective;
+        private AIObjectiveGetItem getItemObjective;
         private AIObjectiveContainItem containObjective;
 
+        public AIObjectiveGetItem GetItemObjective => getItemObjective;
+        public AIObjectiveContainItem ContainObjective => containObjective;
+
         public bool Equip { get; set; }
 
         /// <summary>
@@ -26,7 +29,7 @@ namespace Barotrauma
         /// In both cases abandons the objective.
         /// Note that has no effect if the target container was not defined (always drops) -> completes when the item is dropped.
         /// </summary>
-        public bool DropIfFailsToContain { get; set; } = true;
+        public bool DropIfFails { get; set; } = true;
 
         public AIObjectiveDecontainItem(Character character, Item targetItem, AIObjectiveManager objectiveManager, ItemContainer sourceContainer = null, ItemContainer targetContainer = null, float priorityModifier = 1) 
             : base(character, objectiveManager, priorityModifier)
@@ -74,54 +77,30 @@ namespace Barotrauma
                     return;
                 }
             }
-            else
+            else if (targetContainer.Inventory.Items.Contains(itemToDecontain))
             {
-                if (targetContainer.Inventory.Items.Contains(itemToDecontain))
-                {
-                    IsCompleted = true;
-                    return;
-                }
+                IsCompleted = true;
+                return;
             }
-            if (goToObjective == null && !itemToDecontain.IsOwnedBy(character))
+            if (getItemObjective == null && !itemToDecontain.IsOwnedBy(character))
             {
-                if (sourceContainer == null)
-                {
-                    Abandon = true;
-                    return;
-                }
-                if (!character.CanInteractWith(sourceContainer.Item, out _, checkLinked: false))
-                {
-                    TryAddSubObjective(ref goToObjective,
-                        constructor: () => new AIObjectiveGoTo(sourceContainer.Item, character, objectiveManager)
-                        {
-                            // If the container changes, the item is no longer where it was
-                            abortCondition = () => itemToDecontain.Container != sourceContainer.Item,
-                            DialogueIdentifier = "dialogcannotreachtarget",
-                            TargetName = sourceContainer.Item.Name
-                        },
-                        onAbandon: () => Abandon = true);
-                    return;
-                }
+                TryAddSubObjective(ref getItemObjective,
+                    constructor: () => new AIObjectiveGetItem(character, targetItem, objectiveManager, Equip),
+                    onAbandon: () => Abandon = true);
+                return;
             }
             if (targetContainer != null)
             {
                 TryAddSubObjective(ref containObjective,
                     constructor: () => new AIObjectiveContainItem(character, itemToDecontain, targetContainer, objectiveManager)
                     {
-                        Equip = this.Equip,
+                        Equip = Equip,
                         RemoveEmpty = false,
-                        GetItemPriority = this.GetItemPriority,
+                        GetItemPriority = GetItemPriority,
                         ignoredContainerIdentifiers = sourceContainer != null ? new string[] { sourceContainer.Item.Prefab.Identifier } : null
                     },
                     onCompleted: () => IsCompleted = true,
-                    onAbandon: () =>
-                    {
-                        if (DropIfFailsToContain)
-                        {
-                            itemToDecontain.Drop(character);
-                        }
-                        Abandon = true;
-                    });
+                    onAbandon: () => Abandon = true);
             }
             else
             {
@@ -133,8 +112,17 @@ namespace Barotrauma
         public override void Reset()
         {
             base.Reset();
-            goToObjective = null;
+            getItemObjective = null;
             containObjective = null;
         }
+
+        protected override void OnAbandon()
+        {
+            base.OnAbandon();
+            if (DropIfFails && targetItem != null && targetItem.IsOwnedBy(character))
+            {
+                targetItem.Drop(character);
+            }
+        }
     }
 }

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

@@ -13,6 +13,8 @@ namespace Barotrauma
         public override bool ConcurrentObjectives => true;
         public override bool KeepDivingGearOn => true;
 
+        public override bool AllowInAnySub => true;
+
         private readonly Hull targetHull;
 
         private AIObjectiveGetItem getExtinguisherObjective;
@@ -30,12 +32,15 @@ namespace Barotrauma
             if (!IsAllowed)
             {
                 Priority = 0;
+                Abandon = true;
                 return Priority;
             }
-            if (!objectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>() 
-                && Character.CharacterList.Any(c => c.CurrentHull == targetHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
+            bool isOrder = objectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>();
+            if (!isOrder && Character.CharacterList.Any(c => c.CurrentHull == targetHull && !HumanAIController.IsFriendly(c) && HumanAIController.IsActive(c)))
             {
+                // Don't go into rooms with any enemies, unless it's an order
                 Priority = 0;
+                Abandon = true;
             }
             else
             {
@@ -43,14 +48,22 @@ namespace Barotrauma
                 yDist = yDist > 100 ? yDist * 3 : 0;
                 float dist = Math.Abs(character.WorldPosition.X - targetHull.WorldPosition.X) + yDist;
                 float distanceFactor = MathHelper.Lerp(1, 0.1f, MathUtils.InverseLerp(0, 5000, dist));
-                if (targetHull == character.CurrentHull)
+                if (targetHull == character.CurrentHull || HumanAIController.VisibleHulls.Contains(targetHull))
                 {
                     distanceFactor = 1;
                 }
                 float severity = AIObjectiveExtinguishFires.GetFireSeverity(targetHull);
-                float severityFactor = MathHelper.Lerp(0, 1, severity / 100);
-                float devotion = CumulatedDevotion / 100;
-                Priority = MathHelper.Lerp(0, 100, MathHelper.Clamp(devotion + (severityFactor * distanceFactor * PriorityModifier), 0, 1));
+                if (severity > 0.5f && !isOrder)
+                {
+                    // Ignore severe fires unless ordered. (Let the fire drain all the oxygen instead).
+                    Priority = 0;
+                    Abandon = true;
+                }
+                else
+                {
+                    float devotion = CumulatedDevotion / 100;
+                    Priority = MathHelper.Lerp(0, 100, MathHelper.Clamp(devotion + (severity * distanceFactor * PriorityModifier), 0, 1));
+                }
             }
             return Priority;
         }
@@ -131,13 +144,16 @@ namespace Barotrauma
                     if (move)
                     {
                         //go to the first firesource
-                        TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(fs, character, objectiveManager, closeEnough: extinguisher.Range / 2)
+                        if (TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(fs, character, objectiveManager, closeEnough: extinguisher.Range / 2)
+                            {
+                                DialogueIdentifier = "dialogcannotreachfire",
+                                TargetName = fs.Hull.DisplayName
+                            }, 
+                                onAbandon: () =>  Abandon = true, 
+                                onCompleted: () => RemoveSubObjective(ref gotoObjective)))
                         {
-                            DialogueIdentifier = "dialogcannotreachfire",
-                            TargetName = fs.Hull.DisplayName
-                        }, 
-                            onAbandon: () =>  Abandon = true, 
-                            onCompleted: () => RemoveSubObjective(ref gotoObjective));
+                            gotoObjective.requiredCondition = () => HumanAIController.VisibleHulls.Contains(fs.Hull);
+                        }
                     }
                     else
                     {

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

@@ -1,6 +1,8 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Collections.Generic;
 using Barotrauma.Extensions;
+using Microsoft.Xna.Framework;
 
 namespace Barotrauma
 {
@@ -8,14 +10,22 @@ namespace Barotrauma
     {
         public override string DebugTag => "extinguish fires";
         public override bool ForceRun => true;
+        public override bool AllowInAnySub => true;
 
         public AIObjectiveExtinguishFires(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1) : base(character, objectiveManager, priorityModifier) { }
 
         protected override bool Filter(Hull hull) => IsValidTarget(hull, character);
 
-        protected override float TargetEvaluation() => Targets.Sum(t => GetFireSeverity(t));
+        protected override float TargetEvaluation() => 
+            // If any target is visible -> 100 priority
+            Targets.Any(t => t == character.CurrentHull || HumanAIController.VisibleHulls.Contains(t)) ? 100 : 
+            // Else based on the fire severity
+            Targets.Sum(t =>  GetFireSeverity(t) * 100);
 
-        public static float GetFireSeverity(Hull hull) => hull.FireSources.Sum(fs => fs.Size.X);
+        /// <summary>
+        /// 0-1 based on the horizontal size of all of the fires in the hull.
+        /// </summary>
+        public static float GetFireSeverity(Hull hull) => MathHelper.Lerp(0, 1, MathUtils.InverseLerp(0, Math.Min(hull.Rect.Width, 1000), hull.FireSources.Sum(fs => fs.Size.X)));
 
         protected override IEnumerable<Hull> GetList() => Hull.hullList;
 
@@ -31,22 +41,7 @@ namespace Barotrauma
             if (hull.FireSources.None()) { return false; }
             if (hull.Submarine == null) { return false; }
             if (character.Submarine == null) { return false; }
-            if (!character.Submarine.IsConnectedTo(hull.Submarine)) { return false; }
-            if (character.AIController is HumanAIController humanAI)
-            {
-                if (hull.Submarine.TeamID != character.TeamID)
-                {
-                    if (humanAI.ObjectiveManager.IsCurrentOrder<AIObjectiveExtinguishFires>())
-                    {
-                        // For orders, allow targets in the current sub (for example if the bot is inside an outpost or a wreck)
-                        if (hull.Submarine != character.Submarine) { return false; }
-                    }
-                    else
-                    {
-                        return false;
-                    }
-                }
-            }
+            if (!character.Submarine.IsEntityFoundOnThisSub(hull, includingConnectedSubs: true)) { return false; }
             return true;
         }
     }

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

@@ -17,7 +17,7 @@ namespace Barotrauma
         private Item targetItem;
 
         public static float MIN_OXYGEN = 10;
-        public static string HEAVY_DIVING_GEAR = "heavydiving";
+        public static string HEAVY_DIVING_GEAR = "deepdiving";
         public static string LIGHT_DIVING_GEAR = "lightdiving";
         public static string OXYGEN_SOURCE = "oxygensource";
 

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

@@ -14,8 +14,9 @@ namespace Barotrauma
         public override bool IgnoreUnsafeHulls => true;
         public override bool ConcurrentObjectives => true;
         public override bool AllowOutsideSubmarine => true;
+        public override bool AllowInAnySub => true;
         public override bool AbandonWhenCannotCompleteSubjectives => false;
-        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace); }
+        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace.CleanupStackTrace()); }
 
         // TODO: expose?
         const float priorityIncrease = 100;
@@ -203,11 +204,15 @@ namespace Barotrauma
                         {
                             // Don't ignore any hulls if outside, because apparently it happens that we can't find a path, in which case we just want to try again.
                             // If we ignore the hull, it might be the only airlock in the target sub, which ignores the whole sub.
-                            if (currentHull != null && goToObjective != null)
+                            // If the target hull is inside a submarine that is not our main sub, just ignore it normally when it cannot be reached. This happens with outposts.
+                            if (goToObjective != null)
                             {
                                 if (goToObjective.Target is Hull hull)
                                 {
-                                    HumanAIController.UnreachableHulls.Add(hull);
+                                    if (currentHull != null || !Submarine.MainSubs.Contains(hull.Submarine))
+                                    {
+                                        HumanAIController.UnreachableHulls.Add(hull);
+                                    }
                                 }
                             }
                             RemoveSubObjective(ref goToObjective);

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

@@ -12,6 +12,7 @@ namespace Barotrauma
         public override string DebugTag => "fix leak";
         public override bool ForceRun => true;
         public override bool KeepDivingGearOn => true;
+        public override bool AllowInAnySub => true;
 
         public Gap Leak { get; private set; }
 
@@ -35,11 +36,7 @@ namespace Barotrauma
             if (!IsAllowed)
             {
                 Priority = 0;
-                return Priority;
-            }
-            if (Leak.Removed || Leak.Open <= 0)
-            {
-                Priority = 0;
+                Abandon = true;
             }
             else if (HumanAIController.IsTrueForAnyCrewMember(other => other != HumanAIController && other.ObjectiveManager.GetActiveObjective<AIObjectiveFixLeak>()?.Leak == Leak))
             {
@@ -116,7 +113,7 @@ namespace Barotrauma
             {
                 HumanAIController.AnimController.Crouching = true;
             }
-            float reach = repairTool.Range + ConvertUnits.ToDisplayUnits(((HumanoidAnimController)character.AnimController).ArmLength);
+            float reach = CalculateReach(repairTool, character);
             bool canOperate = toLeak.LengthSquared() < reach * reach;
             if (canOperate)
             {
@@ -144,7 +141,7 @@ namespace Barotrauma
                 onAbandon: () =>
                 {
                     if (Check()) { IsCompleted = true; }
-                    else if ((Leak.WorldPosition - character.WorldPosition).LengthSquared() > reach * reach * 2)
+                    else if ((Leak.WorldPosition - character.WorldPosition).LengthSquared() > MathUtils.Pow(reach * 2, 2))
                     {
                         // Too far
                         Abandon = true;
@@ -167,5 +164,14 @@ namespace Barotrauma
             gotoObjective = null;
             operateObjective = null;
         }
+
+        public static float CalculateReach(RepairTool repairTool, Character character)
+        {
+            float armLength = ConvertUnits.ToDisplayUnits(((HumanoidAnimController)character.AnimController).ArmLength);
+            // This is an approximation, because we don't know the exact reach until the pose is taken.
+            // And even then the actual range depends on the direction we are aiming to.
+            // Found out that without any multiplier the value (209) is often too short.
+            return repairTool.Range + armLength * 1.2f;
+        }
     }
 }

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

@@ -9,6 +9,7 @@ namespace Barotrauma
         public override string DebugTag => "fix leaks";
         public override bool ForceRun => true;
         public override bool KeepDivingGearOn => true;
+        public override bool AllowInAnySub => true;
         private Hull PrioritizedHull { get; set; }
 
         public AIObjectiveFixLeaks(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1, Hull prioritizedHull = null) : base(character, objectiveManager, priorityModifier)
@@ -71,12 +72,9 @@ namespace Barotrauma
         {
             if (gap == null) { return false; }
             if (gap.ConnectedWall == null || gap.ConnectedDoor != null || gap.Open <= 0 || gap.linkedTo.All(l => l == null)) { return false; }
-            if (gap.Submarine == null) { return false; }
-            if (gap.Submarine.TeamID != character.TeamID) { return false; }
-            if (character.Submarine != null)
-            {
-                if (!character.Submarine.IsConnectedTo(gap.Submarine)) { 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.
+            if (!character.Submarine.IsEntityFoundOnThisSub(gap, includingConnectedSubs: true)) { return false; }
             return true;
         }
     }

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

@@ -37,6 +37,7 @@ namespace Barotrauma
         public static float DefaultReach = 100;
 
         public bool AllowToFindDivingGear { get; set; } = true;
+        public bool MustBeSpecificItem { get; set; }
 
         public AIObjectiveGetItem(Character character, Item targetItem, AIObjectiveManager objectiveManager, bool equip = true, float priorityModifier = 1) 
             : base(character, objectiveManager, priorityModifier)
@@ -84,6 +85,11 @@ namespace Barotrauma
                 Abandon = true;
                 return;
             }
+            if (character.Submarine == null)
+            {
+                Abandon = true;
+                return;
+            }
             if (identifiersOrTags != null && !isDoneSeeking)
             {
                 if (checkInventory)
@@ -109,7 +115,10 @@ namespace Barotrauma
                         }
                     }
                     FindTargetItem();
-                    objectiveManager.GetObjective<AIObjectiveIdle>().Wander(deltaTime);
+                    if (!objectiveManager.IsCurrentOrder<AIObjectiveGoTo>())
+                    {
+                        objectiveManager.GetObjective<AIObjectiveIdle>().Wander(deltaTime);
+                    }
                     return;
                 }
             }
@@ -137,7 +146,8 @@ namespace Barotrauma
                 if (originalTarget == null)
                 {
                     // Try again
-                    Reset();
+                    ignoredItems.Add(targetItem);
+                    ResetInternal();
                 }
                 else
                 {
@@ -176,12 +186,8 @@ namespace Barotrauma
                     return;
                 }
 
-                if (HumanAIController.TryToMoveItem(targetItem, character.Inventory))
+                if (HumanAIController.TakeItem(targetItem, character.Inventory, equip, storeUnequipped: true))
                 {
-                    if (equip)
-                    {
-                        targetItem.Equip(character);
-                    }
                     IsCompleted = true;
                 }
                 else
@@ -207,8 +213,16 @@ namespace Barotrauma
                     },
                     onAbandon: () =>
                     {
-                        ignoredItems.Add(targetItem);
-                        Reset();
+                        if (originalTarget == null)
+                        {
+                            // Try again
+                            ignoredItems.Add(targetItem);
+                            ResetInternal();
+                        }
+                        else
+                        {
+                            Abandon = true;
+                        }
                     },
                     onCompleted: () => RemoveSubObjective(ref goToObjective));
             }
@@ -235,14 +249,18 @@ namespace Barotrauma
                 Submarine mySub = character.Submarine;
                 if (itemSub == null) { continue; }
                 if (mySub == null) { continue; }
-                if (itemSub.TeamID != mySub.TeamID && itemSub.TeamID != character.TeamID) { continue; }
                 if (!CheckItem(item)) { continue; }
                 if (ignoredContainerIdentifiers != null && item.Container != null)
                 {
                     if (ignoredContainerIdentifiers.Contains(item.ContainerIdentifier)) { continue; }
                 }
-                if (!mySub.IsConnectedTo(itemSub)) { continue; }
+                // Don't allow going into another sub, unless it's connected and of the same team and type.
+                if (!character.Submarine.IsEntityFoundOnThisSub(item, includingConnectedSubs: true)) { continue; }
                 if (character.IsItemTakenBySomeoneElse(item)) { continue; }
+                if (item.ParentInventory is ItemInventory itemInventory)
+                {
+                    if (!itemInventory.Container.HasRequiredItems(character, addMessage: false)) { continue; }
+                }
                 float itemPriority = 1;
                 if (GetItemPriority != null)
                 {
@@ -272,7 +290,7 @@ namespace Barotrauma
                         if (!(MapEntityPrefab.List.FirstOrDefault(me => me is ItemPrefab ip && identifiersOrTags.Any(id => id == ip.Identifier || ip.Tags.Contains(id))) is ItemPrefab prefab))
                         {
 #if DEBUG
-                            DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s): {string.Join(", ", identifiersOrTags)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
+                            DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s) or tag(s): {string.Join(", ", identifiersOrTags)}, tried to spawn the item but no matching item prefabs were found.", Color.Yellow);
 #endif
                             Abandon = true;
                         }
@@ -291,7 +309,7 @@ namespace Barotrauma
                     else
                     {
 #if DEBUG
-                        DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s): {string.Join(", ", identifiersOrTags)}", Color.Yellow);
+                        DebugConsole.NewMessage($"{character.Name}: Cannot find the item with the following identifier(s) or tag(s): {string.Join(", ", identifiersOrTags)}", Color.Yellow);
 #endif
                         Abandon = true;
                     }
@@ -330,11 +348,28 @@ namespace Barotrauma
         public override void Reset()
         {
             base.Reset();
+            ResetInternal();
+        }
+
+        /// <summary>
+        /// Does not reset the ignored items list
+        /// </summary>
+        private void ResetInternal()
+        {
             goToObjective = null;
             targetItem = originalTarget;
             moveToTarget = targetItem?.GetRootInventoryOwner();
             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);
+            }
+        }
     }
 }

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

@@ -1,5 +1,6 @@
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Barotrauma
@@ -50,6 +51,7 @@ namespace Barotrauma
         public override bool AbandonWhenCannotCompleteSubjectives => !repeat;
 
         public override bool AllowOutsideSubmarine => AllowGoingOutside;
+        public override bool AllowInAnySub => true;
 
         public string DialogueIdentifier { get; set; }
         public string TargetName { get; set; }
@@ -60,17 +62,27 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
+            bool isOrder = objectiveManager.CurrentOrder == this;
+            if (!IsAllowed)
+            {
+                Priority = 0;
+                Abandon = !isOrder;
+                return Priority;
+            }
             if (followControlledCharacter && Character.Controlled == null)
             {
                 Priority = 0;
+                Abandon = !isOrder;
             }
             if (Target is Entity e && e.Removed)
             {
                 Priority = 0;
+                Abandon = !isOrder;
             }
             if (IgnoreIfTargetDead && Target is Character character && character.IsDead)
             {
                 Priority = 0;
+                Abandon = !isOrder;
             }
             else
             {
@@ -84,7 +96,7 @@ namespace Barotrauma
                 }
                 else
                 {
-                    Priority = objectiveManager.CurrentOrder == this ? AIObjectiveManager.OrderPriority : 10;
+                    Priority = isOrder ? AIObjectiveManager.OrderPriority : 10;
                 }
             }
             return Priority;
@@ -93,7 +105,7 @@ namespace Barotrauma
         public AIObjectiveGoTo(ISpatialEntity target, Character character, AIObjectiveManager objectiveManager, bool repeat = false, bool getDivingGearIfNeeded = true, float priorityModifier = 1, float closeEnough = 0)
             : base(character, objectiveManager, priorityModifier)
         {
-            this.Target = target;
+            Target = target;
             this.repeat = repeat;
             waitUntilPathUnreachable = 3.0f;
             this.getDivingGearIfNeeded = getDivingGearIfNeeded;
@@ -260,61 +272,156 @@ namespace Barotrauma
                         }
                     }
                 }
+                if (!character.AnimController.InWater)
+                {
+                    useScooter = false;
+                    checkScooterTimer = 0;
+                }
+                else if (checkScooterTimer <= 0)
+                {
+                    useScooter = false;
+                    checkScooterTimer = checkScooterTime;
+                    string scooterTag = "scooter";
+                    string batteryTag = "mobilebattery";
+                    Item scooter = null;
+                    bool isScooterEquipped = false;
+                    float closeEnough = 250;
+                    float squaredDistance = Vector2.DistanceSquared(character.WorldPosition, Target.WorldPosition);
+                    bool shouldUseScooter = squaredDistance > closeEnough * closeEnough && (!mimic ||
+                        (Target is Character targetCharacter && targetCharacter.HasEquippedItem(scooterTag, allowBroken: false)) || squaredDistance > Math.Pow(closeEnough * 2, 2));
+                    if (HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> equippedScooters, batteryTag, requireEquipped: true))
+                    {
+                        scooter = equippedScooters.FirstOrDefault();
+                        isScooterEquipped = scooter != null;
+                    }
+                    else if (shouldUseScooter && HumanAIController.HasItem(character, scooterTag, out IEnumerable<Item> scooters, batteryTag, requireEquipped: false))
+                    {
+                        scooter = scooters.FirstOrDefault();
+                        if (scooter != null)
+                        {
+                            isScooterEquipped = HumanAIController.TakeItem(scooter, character.Inventory, equip: true, dropOtherIfCannotMove: false, allowSwapping: true, storeUnequipped: false);
+                        }
+                    }
+                    if (scooter != null && isScooterEquipped)
+                    {
+                        if (shouldUseScooter)
+                        {
+                            useScooter = true;
+                        }
+                        else
+                        {
+                            // Unequip
+                            character.Inventory.TryPutItem(scooter, character, CharacterInventory.anySlot);
+                        }
+                    }
+                }
+                else
+                {
+                    checkScooterTimer -= deltaTime;
+                }
                 if (SteeringManager == PathSteering)
                 {
                     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)
                     {
-                        SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(Target.WorldPosition - character.WorldPosition));
+                        if (useScooter)
+                        {
+                            UseScooter(Target.WorldPosition);
+                        }
+                        else
+                        {
+                            SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(Target.WorldPosition - character.WorldPosition));
+                            if (character.AnimController.InWater)
+                            {
+                                SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: 5, weight: 2);
+                            }
+                        }
+                    }
+                    else if (useScooter && PathSteering.CurrentPath?.CurrentNode != null)
+                    {
+                        UseScooter(PathSteering.CurrentPath.CurrentNode.WorldPosition);
+                    }
+                }
+                else
+                {
+                    if (useScooter)
+                    {
+                        UseScooter(Target.WorldPosition);
+                    }
+                    else
+                    {
+                        SteeringManager.SteeringSeek(character.GetRelativeSimPosition(Target), 10);
                         if (character.AnimController.InWater)
                         {
                             SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: 5, weight: 15);
                         }
                     }
                 }
-                else
+            }
+
+            void UseScooter(Vector2 targetWorldPos)
+            {
+                SteeringManager.Reset();
+                character.CursorPosition = targetWorldPos;
+                if (character.Submarine != null)
                 {
-                    SteeringManager.SteeringSeek(character.GetRelativeSimPosition(Target), 10);
-                    SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: 5, weight: 15);
+                    character.CursorPosition -= character.Submarine.Position;
                 }
+                Vector2 dir = Vector2.Normalize(character.CursorPosition - character.Position);
+                if (!MathUtils.IsValid(dir)) { dir = Vector2.UnitY; }
+                SteeringManager.SteeringManual(1.0f, dir);
+                character.SetInput(InputType.Aim, false, true);
+                character.SetInput(InputType.Shoot, false, true);
             }
         }
 
-        public Hull GetTargetHull()
+        private bool useScooter;
+        private float checkScooterTimer;
+        private readonly float checkScooterTime = 0.2f;
+
+        public Hull GetTargetHull() => GetTargetHull(Target);
+
+        public static Hull GetTargetHull(ISpatialEntity target)
         {
-            if (Target is Hull h)
+            if (target is Hull h)
             {
                 return h;
             }
-            else if (Target is Item i)
+            else if (target is Item i)
             {
                 return i.CurrentHull;
             }
-            else if (Target is Character c)
+            else if (target is Character c)
             {
                 return c.CurrentHull;
             }
-            else if (Target is Gap g)
+            else if (target is Gap g)
             {
                 return g.FlowTargetHull;
             }
-            else if (Target is WayPoint wp)
+            else if (target is WayPoint wp)
             {
                 return wp.CurrentHull;
             }
-            else if (Target is FireSource fs)
+            else if (target is FireSource fs)
             {
                 return fs.Hull;
             }
+            else if (target is OrderTarget ot)
+            {
+                return ot.Hull;
+            }
             return null;
         }
 
@@ -361,7 +468,7 @@ namespace Barotrauma
                     {
                         if (Target is Item item)
                         {
-                            if (character.CanInteractWith(item, out _, checkLinked: false)) { IsCompleted = true; }
+                            if (!character.IsClimbing && character.CanInteractWith(item, out _, checkLinked: false)) { IsCompleted = true; }
                         }
                         else if (Target is Character targetCharacter)
                         {

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

@@ -1,4 +1,5 @@
-using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
 using FarseerPhysics;
 using Microsoft.Xna.Framework;
 using System;
@@ -11,14 +12,14 @@ namespace Barotrauma
     {
         public override string DebugTag => "idle";
         public override bool AllowAutomaticItemUnequipping => true;
-        public override bool AllowOutsideSubmarine => true;
+        public override bool AllowInAnySub => true;
 
         private BehaviorType behavior;
         public BehaviorType Behavior
         {
             get { return behavior; }
-            set 
-            { 
+            set
+            {
                 behavior = value;
                 switch (behavior)
                 {
@@ -27,16 +28,13 @@ namespace Barotrauma
                         newTargetIntervalMax = 20;
                         standStillMin = 2;
                         standStillMax = 10;
-                        walkDurationMin = 5;
-                        walkDurationMax = 10;
                         break;
                     case BehaviorType.Passive:
+                    case BehaviorType.StayInHull:
                         newTargetIntervalMin = 60;
                         newTargetIntervalMax = 120;
                         standStillMin = 30;
                         standStillMax = 60;
-                        walkDurationMin = 5;
-                        walkDurationMax = 10;
                         break;
                 }
             }
@@ -46,8 +44,8 @@ namespace Barotrauma
         private float newTargetIntervalMax;
         private float standStillMin;
         private float standStillMax;
-        private float walkDurationMin;
-        private float walkDurationMax;
+        private readonly float walkDurationMin = 5;
+        private readonly float walkDurationMax = 10;
 
         public enum BehaviorType
         {
@@ -55,7 +53,7 @@ namespace Barotrauma
             Passive,
             StayInHull
         }
-
+        public Hull TargetHull { get; set; }
         private Hull currentTarget;
         private float newTargetTimer;
 
@@ -86,7 +84,7 @@ namespace Barotrauma
         protected override bool Check() => false;
         public override bool CanBeCompleted => true;
 
-        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace); }
+        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace.CleanupStackTrace()); }
 
         public readonly HashSet<string> PreferredOutpostModuleTypes = new HashSet<string>();
 
@@ -142,6 +140,8 @@ namespace Barotrauma
             timerMargin = 0;
         }
 
+        private bool IsSteeringFinished() => PathSteering.CurrentPath != null && (PathSteering.CurrentPath.Finished || PathSteering.CurrentPath.Unreachable);
+
         protected override void Act(float deltaTime)
         {
             if (PathSteering == null) { return; }
@@ -164,12 +164,30 @@ namespace Barotrauma
                 character.DeselectCharacter();
             }
 
-            if (behavior != BehaviorType.StayInHull)
+            if (!character.IsClimbing)
             {
-                bool currentTargetIsInvalid = currentTarget == null || IsForbidden(currentTarget) || 
-                    (PathSteering.CurrentPath != null && PathSteering.CurrentPath.Nodes.Any(n => HumanAIController.UnsafeHulls.Contains(n.CurrentHull)));
+                character.SelectedConstruction = null;
+            }
 
-                bool IsSteeringFinished() => PathSteering.CurrentPath != null && (PathSteering.CurrentPath.Finished || PathSteering.CurrentPath.Unreachable);
+            CleanupItems(deltaTime);
+
+            if (behavior == BehaviorType.StayInHull)
+            {
+                currentTarget = TargetHull;
+                bool stayInHull = character.CurrentHull == currentTarget && IsSteeringFinished() && !character.IsClimbing;
+                if (stayInHull)
+                {
+                    Wander(deltaTime);
+                }
+                else if (currentTarget != null)
+                {
+                    PathSteering.SteeringSeek(character.GetRelativeSimPosition(currentTarget), weight: 1, nodeFilter: node => node.Waypoint.CurrentHull != null);
+                }
+            }
+            else
+            {
+                bool currentTargetIsInvalid = currentTarget == null || IsForbidden(currentTarget) ||
+                    (PathSteering.CurrentPath != null && PathSteering.CurrentPath.Nodes.Any(n => HumanAIController.UnsafeHulls.Contains(n.CurrentHull)));
 
                 if (currentTarget != null && !currentTargetIsInvalid)
                 {
@@ -226,7 +244,7 @@ namespace Barotrauma
                         searchingNewHull = true;
                         return;
                     }
-                    else if (targetHulls.Count > 0)
+                    else if (targetHulls.Any())
                     {
                         //choose a random available hull
                         currentTarget = ToolBox.SelectWeightedRandom(targetHulls, hullWeights, Rand.RandSync.Unsynced);
@@ -242,12 +260,13 @@ namespace Barotrauma
                         });
                         if (path.Unreachable)
                         {
-                            //can't go to this room, remove it from the list and try another room next frame
+                            //can't go to this room, remove it from the list and try another room
                             int index = targetHulls.IndexOf(currentTarget);
                             targetHulls.RemoveAt(index);
                             hullWeights.RemoveAt(index);
                             PathSteering.Reset();
                             currentTarget = null;
+                            SetTargetTimerLow();
                             return;
                         }
                         searchingNewHull = false;
@@ -263,47 +282,25 @@ namespace Barotrauma
                     {
                         character.AIController.SelectTarget(currentTarget.AiTarget);
                         string errorMsg = null;
-    #if DEBUG
+#if DEBUG
                         bool isRoomNameFound = currentTarget.DisplayName != null;
                         errorMsg = "(Character " + character.Name + " idling, target " + (isRoomNameFound ? currentTarget.DisplayName : currentTarget.ToString()) + ")";
-    #endif
+#endif
                         var path = PathSteering.PathFinder.FindPath(character.SimPosition, currentTarget.SimPosition, errorMsgStr: errorMsg, nodeFilter: node => node.Waypoint.CurrentHull != null);
                         PathSteering.SetPath(path);
                     }
                     SetTargetTimerNormal();
-                }            
+                }
                 newTargetTimer -= deltaTime;
-            }
 
-            //wander randomly 
-            // - if reached the end of the path 
-            // - if the target is unreachable
-            // - if the path requires going outside
-            if (!character.IsClimbing)
-            {
-                if (behavior == BehaviorType.StayInHull || SteeringManager != PathSteering || (PathSteering.CurrentPath != null &&
-                    (PathSteering.CurrentPath.Finished || PathSteering.CurrentPath.Unreachable || PathSteering.CurrentPath.HasOutdoorsNodes)))
+                if (!character.IsClimbing && IsSteeringFinished())
                 {
                     Wander(deltaTime);
-                    return;
                 }
-                character.SelectedConstruction = null;
-            }
-
-            if (currentTarget != null)
-            {
-                if (SteeringManager == PathSteering)
+                else if (currentTarget != null)
                 {
                     PathSteering.SteeringSeek(character.GetRelativeSimPosition(currentTarget), weight: 1, nodeFilter: node => node.Waypoint.CurrentHull != null);
                 }
-                else
-                {
-                    character.AIController.SteeringManager.SteeringSeek(character.GetRelativeSimPosition(currentTarget));
-                }
-            }
-            else
-            {
-                Wander(deltaTime);
             }
         }
 
@@ -328,7 +325,7 @@ namespace Barotrauma
                             {
                                 //if there are characters too close on both sides, don't try to steer away from them
                                 //because it'll cause the character to spaz out trying to avoid both
-                                if (tooCloseCharacter != null && 
+                                if (tooCloseCharacter != null &&
                                     Math.Sign(tooCloseCharacter.WorldPosition.X - character.WorldPosition.X) != Math.Sign(c.WorldPosition.X - character.WorldPosition.X))
                                 {
                                     tooCloseCharacter = null;
@@ -336,7 +333,7 @@ namespace Barotrauma
                                 }
                                 tooCloseCharacter = c;
                             }
-                            HumanAIController.FaceTarget(c);                            
+                            HumanAIController.FaceTarget(c);
                         }
                     }
 
@@ -344,7 +341,7 @@ namespace Barotrauma
                     {
                         Vector2 diff = character.WorldPosition - tooCloseCharacter.WorldPosition;
                         if (diff.LengthSquared() < 0.0001f) { diff = Rand.Vector(1.0f); }
-                        if (Math.Abs(diff.X) > 0 && 
+                        if (Math.Abs(diff.X) > 0 &&
                             (character.WorldPosition.X > currentHull.WorldRect.Right - 50 || character.WorldPosition.X < currentHull.WorldRect.Left + 50))
                         {
                             // Between a wall and a character -> move away
@@ -459,6 +456,48 @@ namespace Barotrauma
             }
         }
 
+        #region Cleaning
+        private readonly float checkItemsInterval = 1;
+        private float checkItemsTimer;
+        private readonly List<Item> itemsToClean = new List<Item>();
+        private readonly List<Item> ignoredItems = new List<Item>();
+
+        private void CleanupItems(float deltaTime)
+        {
+            if (checkItemsTimer <= 0)
+            {
+                checkItemsTimer = checkItemsInterval * Rand.Range(0.9f, 1.1f);
+                var hull = character.CurrentHull;
+                if (hull != null)
+                {
+                    itemsToClean.Clear();
+                    foreach (Item item in Item.ItemList)
+                    {
+                        if (item.CurrentHull != hull) { continue; }
+                        if (AIObjectiveCleanupItems.IsValidTarget(item, character) && !ignoredItems.Contains(item))
+                        {
+                            itemsToClean.Add(item);
+                        }
+                    }
+                    if (itemsToClean.Any())
+                    {
+                        var targetItem = itemsToClean.OrderBy(i => Math.Abs(character.WorldPosition.X - i.WorldPosition.X)).FirstOrDefault();
+                        if (targetItem != null)
+                        {
+                            var cleanupObjective = new AIObjectiveCleanupItem(targetItem, character, objectiveManager, PriorityModifier);
+                            cleanupObjective.Abandoned += () => ignoredItems.Add(targetItem);
+                            subObjectives.Add(cleanupObjective);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                checkItemsTimer -= deltaTime;
+            }
+        }
+        #endregion
+
         public static bool IsForbidden(Hull hull)
         {
             if (hull == null) { return true; }
@@ -475,6 +514,9 @@ namespace Barotrauma
             tooCloseCharacter = null;
             targetHulls.Clear();
             hullWeights.Clear();
+            checkItemsTimer = 0;;
+            itemsToClean.Clear();
+            ignoredItems.Clear();
             autonomousObjectiveRetryTimer = 10;
         }
     }

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Barotrauma.Extensions;
 using Microsoft.Xna.Framework;
 
 namespace Barotrauma
@@ -46,7 +45,7 @@ namespace Barotrauma
         public override bool AllowSubObjectiveSorting => true;
         public virtual bool InverseTargetEvaluation => false;
 
-        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + System.Environment.StackTrace); }
+        public override bool IsLoop { get => true; set => throw new Exception("Trying to set the value for IsLoop from: " + System.Environment.StackTrace.CleanupStackTrace()); }
 
         public override void Update(float deltaTime)
         {
@@ -79,7 +78,12 @@ namespace Barotrauma
                     var target = objective.Key;
                     if (!Targets.Contains(target))
                     {
-                        subObjectives.Remove(objective.Value);
+                        var subObjective = objective.Value;
+                        if (CurrentSubObjective == subObjective)
+                        {
+                            CurrentSubObjective.Abandon = !CurrentSubObjective.IsCompleted;
+                        }
+                        subObjectives.Remove(subObjective);
                     }
                 }
                 SyncRemovedObjectives(Objectives, GetList());
@@ -137,7 +141,7 @@ namespace Barotrauma
                 {
                     if (objectiveManager.CurrentOrder == this)
                     {
-                        Priority = AIObjectiveManager.OrderPriority;
+                        Priority = ForceOrderPriority ? AIObjectiveManager.OrderPriority : targetValue;
                     }
                     else
                     {

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

@@ -70,7 +70,7 @@ namespace Barotrauma
             if (objective == null)
             {
 #if DEBUG
-                DebugConsole.ThrowError("Attempted to add a null objective to AIObjectiveManager\n" + Environment.StackTrace);
+                DebugConsole.ThrowError("Attempted to add a null objective to AIObjectiveManager\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                 return;
             }
@@ -128,8 +128,7 @@ namespace Barotrauma
                 var orderPrefab = Order.GetPrefab(autonomousObjective.identifier);
                 if (orderPrefab == null) { throw new Exception($"Could not find a matching prefab by the identifier: '{autonomousObjective.identifier}'"); }
                 var item = orderPrefab.MustSetTarget ? orderPrefab.GetMatchingItems(character.Submarine, mustBelongToPlayerSub: false, requiredTeam: character.Info.TeamID)?.GetRandom() : null;
-                var order = new Order(orderPrefab, item ?? character.CurrentHull as Entity,
-                    item?.Components.FirstOrDefault(ic => ic.GetType() == orderPrefab.ItemComponentType), orderGiver: character);
+                var order = new Order(orderPrefab, item ?? character.CurrentHull as Entity, orderPrefab.GetTargetItemComponent(item), orderGiver: character);
                 if (order == null) { continue; }
                 if (autonomousObjective.ignoreAtOutpost && Level.IsLoadedOutpost && character.TeamID != Character.TeamType.FriendlyNPC) { continue; }
                 var objective = CreateObjective(order, autonomousObjective.option, character, isAutonomous: true, autonomousObjective.priorityModifier);
@@ -147,7 +146,7 @@ namespace Barotrauma
             if (objective == null)
             {
 #if DEBUG
-                DebugConsole.ThrowError($"{character.Name}: Attempted to add a null objective to AIObjectiveManager\n" + Environment.StackTrace);
+                DebugConsole.ThrowError($"{character.Name}: Attempted to add a null objective to AIObjectiveManager\n" + Environment.StackTrace.CleanupStackTrace());
 #endif
                 return;
             }
@@ -314,9 +313,10 @@ namespace Barotrauma
                     };
                     break;
                 case "wait":
-                    newObjective = new AIObjectiveGoTo(order.TargetEntity ?? character, character, this, repeat: true, priorityModifier: priorityModifier)
+                    newObjective = new AIObjectiveGoTo(order.TargetSpatialEntity ?? character, character, this, repeat: true, priorityModifier: priorityModifier)
                     {
-                        AllowGoingOutside = character.CurrentHull == null
+                        AllowGoingOutside = order.TargetSpatialEntity == null ? character.CurrentHull == null :
+                            character.Submarine == null || character.Submarine != order.TargetSpatialEntity.Submarine
                     };
                     break;
                 case "fixleaks":
@@ -374,6 +374,32 @@ namespace Barotrauma
                         Override = orderGiver != null && orderGiver.IsPlayer
                     };
                     break;
+                case "setchargepct":
+                    newObjective = new AIObjectiveOperateItem(order.TargetItemComponent, character, this, option, false, priorityModifier: priorityModifier)
+                    {
+                        IsLoop = false,
+                        Override = character.CurrentOrder != null,
+                        completionCondition = () =>
+                        {
+                            if (float.TryParse(option, out float pct))
+                            {
+                                var targetRatio = Math.Clamp(pct, 0f, 1f);
+                                var currentRatio = (order.TargetItemComponent as PowerContainer).RechargeRatio;
+                                return Math.Abs(targetRatio - currentRatio) < 0.05f;
+                            }
+                            return true;
+                        }
+                    };
+                    break;
+                case "getitem":
+                    newObjective = new AIObjectiveGetItem(character, order.TargetEntity as Item ?? order.TargetItemComponent?.Item, this, false, priorityModifier: priorityModifier)
+                    {
+                        MustBeSpecificItem = true
+                    };
+                    break;
+                case "cleanupitems":
+                    newObjective = new AIObjectiveCleanupItems(character, this, priorityModifier, order.TargetEntity as Item);
+                    break;
                 default:
                     if (order.TargetItemComponent == null) { return null; }
                     if (order.TargetItemComponent.Item.NonInteractable) { return null; }

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

@@ -11,6 +11,7 @@ namespace Barotrauma
         public override string DebugTag => $"operate item {component.Name}";
         public override bool AllowAutomaticItemUnequipping => true;
         public override bool AllowMultipleInstances => true;
+        public override bool AllowInAnySub => true;
 
         private ItemComponent component, controller;
         private Entity operateTarget;
@@ -35,9 +36,11 @@ namespace Barotrauma
 
         public override float GetPriority()
         {
+            bool isOrder = objectiveManager.CurrentOrder == this;
             if (!IsAllowed || character.LockHands)
             {
                 Priority = 0;
+                Abandon = !isOrder;
                 return Priority;
             }
             if (component.Item.ConditionPercentage <= 0)
@@ -46,7 +49,6 @@ namespace Barotrauma
             }
             else
             {
-                bool isOrder = objectiveManager.CurrentOrder == this;
                 if (isOrder)
                 {
                     Priority = AIObjectiveManager.OrderPriority;
@@ -172,7 +174,7 @@ namespace Barotrauma
             }
             if (target.CanBeSelected)
             {
-                if (character.CanInteractWith(target.Item, out _, checkLinked: false))
+                if (!character.IsClimbing && character.CanInteractWith(target.Item, out _, checkLinked: false))
                 {
                     HumanAIController.FaceTarget(target.Item);
                     if (character.SelectedConstruction != target.Item)
@@ -189,7 +191,8 @@ namespace Barotrauma
                     TryAddSubObjective(ref goToObjective, () => new AIObjectiveGoTo(target.Item, character, objectiveManager, closeEnough: 50)
                     {
                         DialogueIdentifier = "dialogcannotreachtarget",
-                        TargetName = target.Item.Name
+                        TargetName = target.Item.Name,
+                        endNodeFilter = node => node.Waypoint.Ladders == null
                     },
                         onAbandon: () => Abandon = true,
                         onCompleted: () => RemoveSubObjective(ref goToObjective));

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

@@ -10,6 +10,8 @@ namespace Barotrauma
     {
         public override string DebugTag => "repair item";
 
+        public override bool AllowInAnySub => true;
+
         public Item Item { get; private set; }
 
         private AIObjectiveGoTo goToObjective;
@@ -34,6 +36,7 @@ namespace Barotrauma
             if (!IsAllowed)
             {
                 Priority = 0;
+                Abandon = true;
                 return Priority;
             }
             // TODO: priority list?
@@ -69,7 +72,7 @@ namespace Barotrauma
             IsCompleted = Item.IsFullCondition;
             if (IsCompleted && IsRepairing())
             {
-                character?.Speak(TextManager.GetWithVariable("DialogItemRepaired", "[itemname]", Item.Name, true), null, 0.0f, "itemrepaired", 10.0f);
+                character.Speak(TextManager.GetWithVariable("DialogItemRepaired", "[itemname]", Item.Name, true), null, 0.0f, "itemrepaired", 10.0f);
             }
             return IsCompleted;
         }
@@ -134,7 +137,7 @@ namespace Barotrauma
                     return;
                 }
             }
-            if (character.CanInteractWith(Item, out _, checkLinked: false))
+            if (!character.IsClimbing && character.CanInteractWith(Item, out _, checkLinked: false))
             {
                 HumanAIController.FaceTarget(Item);
                 if (repairTool != null)
@@ -235,7 +238,11 @@ namespace Barotrauma
 
         private void OperateRepairTool(float deltaTime)
         {
-            character.CursorPosition = Item.Position;
+            character.CursorPosition = Item.WorldPosition;
+            if (character.Submarine != null)
+            {
+                character.CursorPosition -= character.Submarine.Position;
+            }
             if (repairTool.Item.RequireAimToUse)
             {
                 character.SetInput(InputType.Aim, false, true);

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

@@ -24,11 +24,11 @@ namespace Barotrauma
         private readonly Item prioritizedItem;
 
         public override bool AllowMultipleInstances => true;
+        public override bool AllowInAnySub => true;
 
         public readonly static float RequiredSuccessFactor = 0.4f;
 
-        public override bool IsDuplicate<T>(T otherObjective) => 
-            (otherObjective as AIObjective) is AIObjectiveRepairItems repairObjective && repairObjective.RequireAdequateSkills == RequireAdequateSkills;
+        public override bool IsDuplicate<T>(T otherObjective) => otherObjective is AIObjectiveRepairItems repairObjective && repairObjective.RequireAdequateSkills == RequireAdequateSkills;
 
         public AIObjectiveRepairItems(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1, Item prioritizedItem = null)
             : base(character, objectiveManager, priorityModifier)
@@ -151,13 +151,9 @@ namespace Barotrauma
             if (item.NonInteractable) { return false; }
             if (item.IsFullCondition) { return false; }
             if (item.CurrentHull == null) { return false; }
-            if (item.Submarine == null) { return false; }
-            if (item.Submarine.TeamID != character.TeamID) { return false; }
+            if (item.Submarine == null || character.Submarine == null) { return false; }
+            if (!character.Submarine.IsEntityFoundOnThisSub(item, includingConnectedSubs: true)) { return false; }
             if (item.Repairables.None()) { return false; }
-            if (character.Submarine != null)
-            {
-                if (!character.Submarine.IsConnectedTo(item.Submarine)) { return false; }
-            }
             return true;
         }
     }

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

@@ -14,6 +14,7 @@ namespace Barotrauma
         public override bool KeepDivingGearOn => true;
 
         public override bool AllowOutsideSubmarine => true;
+        public override bool AllowInAnySub => true;
 
         const float TreatmentDelay = 0.5f;
 
@@ -35,7 +36,7 @@ namespace Barotrauma
         {
             if (targetCharacter == null)
             {
-                string errorMsg = $"{character.Name}: Attempted to create a Rescue objective with no target!\n" + Environment.StackTrace;
+                string errorMsg = $"{character.Name}: Attempted to create a Rescue objective with no target!\n" + Environment.StackTrace.CleanupStackTrace();
                 DebugConsole.ThrowError(errorMsg);
                 GameAnalyticsManager.AddErrorEventOnce("AIObjectiveRescue:ctor:targetnull", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
                 Abandon = true;
@@ -392,11 +393,13 @@ namespace Barotrauma
             if (!IsAllowed)
             {
                 Priority = 0;
+                Abandon = true;
                 return Priority;
             }
             if (character.LockHands || targetCharacter == null || targetCharacter.CurrentHull == null || targetCharacter.Removed || targetCharacter.IsDead)
             {
                 Priority = 0;
+                Abandon = true;
             }
             else
             {

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

@@ -11,6 +11,7 @@ namespace Barotrauma
         public override bool ForceRun => true;
         public override bool InverseTargetEvaluation => true;
         public override bool AllowOutsideSubmarine => true;
+        public override bool AllowInAnySub => true;
 
         private const float vitalityThreshold = 75;
         private const float vitalityThresholdForOrders = 85;

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Order.cs

@@ -38,7 +38,8 @@ namespace Barotrauma
         }
 
         public bool MatchesOrder(Order order, string option) =>
-            order.Identifier == Order.Identifier && option == OrderOption && order.TargetEntity == Order.TargetEntity;
+            order.Identifier == Order.Identifier &&
+            option == OrderOption;
     }
 
     class Order
@@ -54,7 +55,7 @@ namespace Barotrauma
             }
             return order;
         }
-        
+
         public Order Prefab { get; private set; }
 
         public readonly string Name;
@@ -62,7 +63,8 @@ namespace Barotrauma
         public readonly Sprite SymbolSprite;
 
         public readonly Type ItemComponentType;
-        public readonly string[] ItemIdentifiers;
+        public readonly bool CanTypeBeSubclass;
+        public readonly string[] TargetItems;
 
         public readonly string Identifier;
 
@@ -89,14 +91,14 @@ namespace Barotrauma
                 color = value;
             }
         }
-        
+
 
         //if true, the order is issued to all available characters
         public bool TargetAllCharacters;
 
         public readonly float FadeOutTime;
 
-        public Entity TargetEntity; 
+        public Entity TargetEntity;
         public ItemComponent TargetItemComponent;
         public readonly bool UseController;
         public Controller ConnectedController;
@@ -123,6 +125,18 @@ namespace Barotrauma
         public bool IsPrefab { get; private set; }
         public readonly bool MustManuallyAssign;
 
+        public readonly OrderTarget TargetPosition;
+
+        private ISpatialEntity targetSpatialEntity;
+        public ISpatialEntity TargetSpatialEntity
+        {
+            get
+            {
+                if (targetSpatialEntity == null) { targetSpatialEntity = TargetEntity ?? TargetPosition as ISpatialEntity; }
+                return targetSpatialEntity;
+            }
+        }
+
         public static void Init()
         {
             Prefabs = new Dictionary<string, Order>();
@@ -218,8 +232,9 @@ namespace Barotrauma
                     DebugConsole.ThrowError("Error in the order definitions: item component type " + targetItemType + " not found", e);
                 }
             }
+            CanTypeBeSubclass = orderElement.GetAttributeBool("cantypebesubclass", false);
 
-            ItemIdentifiers = orderElement.GetAttributeStringArray("targetitemidentifiers", new string[0], trim: true, convertToLowerInvariant: true);
+            TargetItems = orderElement.GetAttributeStringArray("targetitems", new string[0], trim: true, convertToLowerInvariant: true);
             color = orderElement.GetAttributeColor("color");
             FadeOutTime = orderElement.GetAttributeFloat("fadeouttime", 0.0f);
             UseController = orderElement.GetAttributeBool("usecontroller", false);
@@ -228,7 +243,6 @@ namespace Barotrauma
             Options = orderElement.GetAttributeStringArray("options", new string[0]);
             var category = orderElement.GetAttributeString("category", null);
             if (!string.IsNullOrWhiteSpace(category)) { this.Category = (OrderCategory)Enum.Parse(typeof(OrderCategory), category, true); }
-            Weight = orderElement.GetAttributeFloat(0.0f, "weight");
             MustSetTarget = orderElement.GetAttributeBool("mustsettarget", false);
             AppropriateSkill = orderElement.GetAttributeString("appropriateskill", null);
 
@@ -279,7 +293,7 @@ namespace Barotrauma
             IsPrefab = true;
             MustManuallyAssign = orderElement.GetAttributeBool("mustmanuallyassign", false);
         }
-        
+
         /// <summary>
         /// Constructor for order instances
         /// </summary>
@@ -290,7 +304,8 @@ namespace Barotrauma
             Name                = prefab.Name;
             Identifier          = prefab.Identifier;
             ItemComponentType   = prefab.ItemComponentType;
-            ItemIdentifiers     = prefab.ItemIdentifiers;
+            CanTypeBeSubclass   = prefab.CanTypeBeSubclass;
+            TargetItems         = prefab.TargetItems;
             Options             = prefab.Options;
             SymbolSprite        = prefab.SymbolSprite;
             Color               = prefab.Color;
@@ -298,7 +313,6 @@ namespace Barotrauma
             TargetAllCharacters = prefab.TargetAllCharacters;
             AppropriateJobs     = prefab.AppropriateJobs;
             FadeOutTime         = prefab.FadeOutTime;
-            Weight              = prefab.Weight;
             MustSetTarget       = prefab.MustSetTarget;
             AppropriateSkill    = prefab.AppropriateSkill;
             Category            = prefab.Category;
@@ -325,6 +339,11 @@ namespace Barotrauma
 
             IsPrefab = false;
         }
+
+        public Order(Order prefab, OrderTarget target, Character orderGiver = null) : this(prefab, targetEntity: null, targetItem: null, orderGiver)
+        {
+            TargetPosition = target;
+        }
         
         public bool HasAppropriateJob(Character character)
         {
@@ -358,15 +377,38 @@ namespace Barotrauma
             return msg;
         }
 
+        /// <summary>
+        /// Get the target item component based on the target item type
+        /// </summary>
+        public ItemComponent GetTargetItemComponent(Item item)
+        {
+            if (item?.Components == null || ItemComponentType == null) { return null; }
+            foreach (ItemComponent component in item.Components)
+            {
+                if (component?.GetType() is Type componentType)
+                {
+                    if (componentType == ItemComponentType) { return component; }
+                    if (CanTypeBeSubclass && componentType.IsSubclassOf(ItemComponentType)) { return component; }
+                }
+            }
+            return null;
+        }
+
+        public bool TryGetTargetItemComponent(Item item, out ItemComponent firstMatchingComponent)
+        {
+            firstMatchingComponent = GetTargetItemComponent(item);
+            return firstMatchingComponent != null;
+        }
+
         public List<Item> GetMatchingItems(Submarine submarine, bool mustBelongToPlayerSub, Character.TeamType? requiredTeam = null)
         {
             List<Item> matchingItems = new List<Item>();
             if (submarine == null) { return matchingItems; }
-            if (ItemComponentType != null || ItemIdentifiers.Length > 0)
+            if (ItemComponentType != null || TargetItems.Length > 0)
             {
-                matchingItems = ItemIdentifiers.Length > 0 ?
-                    Item.ItemList.FindAll(it => ItemIdentifiers.Contains(it.Prefab.Identifier) || it.HasTag(ItemIdentifiers)) :
-                    Item.ItemList.FindAll(it => it.Components.Any(ic => ic.GetType() == ItemComponentType));
+                matchingItems = TargetItems.Length > 0 ?
+                    Item.ItemList.FindAll(it => TargetItems.Contains(it.Prefab.Identifier) || it.HasTag(TargetItems)) :
+                    Item.ItemList.FindAll(it => TryGetTargetItemComponent(it, out _));
                 if (mustBelongToPlayerSub)
                 {
                     matchingItems.RemoveAll(it => it.Submarine?.Info != null && it.Submarine.Info.Type != SubmarineType.Player);

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/PathFinder.cs

@@ -92,8 +92,10 @@ namespace Barotrauma
         public GetNodePenaltyHandler GetNodePenalty;
 
         private readonly List<PathNode> nodes;
+        public readonly bool IndoorsSteering;
 
         public bool InsideSubmarine { get; set; }
+        public bool ApplyPenaltyToOutsideNodes { get; set; }
 
         public PathFinder(List<WayPoint> wayPoints, bool indoorsSteering = false)
         {
@@ -104,7 +106,7 @@ namespace Barotrauma
                 wp.linkedTo.CollectionChanged += WaypointLinksChanged;
             }
 
-            InsideSubmarine = indoorsSteering;
+            IndoorsSteering = indoorsSteering;
         }
 
         void WaypointLinksChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
@@ -178,7 +180,7 @@ namespace Barotrauma
                 node.TempDistance = xDiff + (InsideSubmarine ? yDiff * 10.0f : yDiff); //higher cost for vertical movement when inside the sub
 
                 //much higher cost to waypoints that are outside
-                if (node.Waypoint.CurrentHull == null && InsideSubmarine) { node.TempDistance *= 10.0f; }
+                if (node.Waypoint.CurrentHull == null && ApplyPenaltyToOutsideNodes) { node.TempDistance *= 10.0f; }
 
                 //prefer nodes that are closer to the end position
                 node.TempDistance += (Math.Abs(end.X - node.TempPosition.X) + Math.Abs(end.Y - node.TempPosition.Y)) / 100.0f;
@@ -200,11 +202,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)
                         {
@@ -231,8 +235,11 @@ namespace Barotrauma
                 node.TempDistance = Vector2.DistanceSquared(end, node.TempPosition);
                 if (InsideSubmarine)
                 {
-                    //much higher cost to waypoints that are outside
-                    if (node.Waypoint.CurrentHull == null) { node.TempDistance *= 10.0f; }
+                    if (ApplyPenaltyToOutsideNodes)
+                    {
+                        //much higher cost to waypoints that are outside
+                        if (node.Waypoint.CurrentHull == null) { node.TempDistance *= 10.0f; }
+                    }
                     //avoid stopping at a doorway
                     if (node.Waypoint.ConnectedDoor != null) { node.TempDistance *= 10.0f; }
                     //avoid stopping at a ladder
@@ -255,17 +262,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;
@@ -339,6 +349,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)
                     {

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/PetBehavior.cs

@@ -0,0 +1,429 @@
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class PetBehavior
+    {
+        public enum StatusIndicatorType
+        {
+            None,
+            Happy,
+            Sad,
+            Hungry
+        }
+
+        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; }
+
+        public float HappinessDecreaseRate { get; set; }
+        public float HungerIncreaseRate { get; set; }
+
+        public float PlayForce { get; set; }
+
+        public float PlayTimer { get; set; }
+        private float? unstunY { get; set; }
+
+        public EnemyAIController AiController { get; private set; } = null;
+
+        public Character Owner { get; set; }
+
+        private class ItemProduction
+        {
+            public struct Item
+            {
+                public ItemPrefab Prefab;
+                public float Commonness;
+            }
+            public List<Item> Items;
+            public Vector2 HungerRange;
+            public Vector2 HappinessRange;
+            public float Rate;
+            public float HungerRate;
+            public float InvHungerRate;
+            public float HappinessRate;
+            public float InvHappinessRate;
+
+            private readonly float totalCommonness;
+            private float timer;
+
+            public ItemProduction(XElement element)
+            {
+                Items = new List<Item>();
+
+                HungerRate = element.GetAttributeFloat("hungerrate", 0.0f);
+                InvHungerRate = element.GetAttributeFloat("invhungerrate", 0.0f);
+                HappinessRate = element.GetAttributeFloat("happinessrate", 0.0f);
+                InvHappinessRate = element.GetAttributeFloat("invhappinessrate", 0.0f);
+
+                string[] requiredHappinessStr = element.GetAttributeString("requiredhappiness", "0-100").Split('-');
+                string[] requiredHungerStr = element.GetAttributeString("requiredhunger", "0-100").Split('-');
+                HappinessRange = new Vector2(0, 100);
+                HungerRange = new Vector2(0, 100);
+                float tempF;
+                if (requiredHappinessStr.Length >= 2)
+                {
+                    if (float.TryParse(requiredHappinessStr[0], NumberStyles.Any, CultureInfo.InvariantCulture, out tempF)) { HappinessRange.X = tempF; }
+                    if (float.TryParse(requiredHappinessStr[1], NumberStyles.Any, CultureInfo.InvariantCulture, out tempF)) { HappinessRange.Y = tempF; }
+                }
+                if (requiredHungerStr.Length >= 2)
+                {
+                    if (float.TryParse(requiredHungerStr[0], NumberStyles.Any, CultureInfo.InvariantCulture, out tempF)) { HungerRange.X = tempF; }
+                    if (float.TryParse(requiredHungerStr[1], NumberStyles.Any, CultureInfo.InvariantCulture, out tempF)) { HungerRange.Y = tempF; }
+                }
+                Rate = element.GetAttributeFloat("rate", 0.016f);
+                totalCommonness = 0.0f;
+                foreach (XElement subElement in element.Elements())
+                {
+                    switch (subElement.Name.LocalName.ToLowerInvariant())
+                    {
+                        case "item":
+                            string identifier = subElement.GetAttributeString("identifier", "");
+                            Item newItemToProduce = new Item
+                            {
+                                Prefab = string.IsNullOrEmpty(identifier) ? null : ItemPrefab.Find("", subElement.GetAttributeString("identifier", "")),
+                                Commonness = subElement.GetAttributeFloat("commonness", 0.0f)
+                            };
+                            totalCommonness += newItemToProduce.Commonness;
+                            Items.Add(newItemToProduce);
+                            break;
+                    }
+                }
+
+                timer = 1.0f;
+            }
+
+            public void Update(PetBehavior pet, float deltaTime)
+            {
+                if (pet.Happiness < HappinessRange.X || pet.Happiness > HappinessRange.Y) { return; }
+                if (pet.Hunger < HungerRange.X || pet.Hunger > HungerRange.Y) { return; }
+
+                float currentRate = Rate;
+                currentRate += HappinessRate * (pet.Happiness - HappinessRange.X) / (HappinessRange.Y - HappinessRange.X);
+                currentRate += InvHappinessRate * (1.0f - ((pet.Happiness - HappinessRange.X) / (HappinessRange.Y - HappinessRange.X)));
+                currentRate += HungerRate * (pet.Hunger - HungerRange.X) / (HungerRange.Y - HungerRange.X);
+                currentRate += InvHungerRate * (1.0f - ((pet.Hunger - HungerRange.X) / (HungerRange.Y - HungerRange.X)));
+                timer -= currentRate * deltaTime;
+                if (timer <= 0.0f)
+                {
+                    timer = 1.0f;
+                    float r = Rand.Range(0.0f, totalCommonness);
+                    float aggregate = 0.0f;
+                    for (int i = 0; i < Items.Count; i++)
+                    {
+                        aggregate += Items[i].Commonness;
+                        if (aggregate >= r && Items[i].Prefab != null)
+                        {
+                            Entity.Spawner.AddToSpawnQueue(Items[i].Prefab, pet.AiController.Character.WorldPosition);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        private class Food
+        {
+            public string Tag;
+            public Vector2 HungerRange;
+            public float Hunger;
+            public float Happiness;
+            public float Priority;
+            public bool IgnoreContained;
+
+            public CharacterParams.TargetParams TargetParams = null;
+        }
+
+        private readonly List<ItemProduction> itemsToProduce = new List<ItemProduction>();
+        private readonly List<Food> foods = new List<Food>();
+
+        public PetBehavior(XElement element, EnemyAIController aiController)
+        {
+            AiController = aiController;
+            AiController.Character.CanBeDragged = true;
+
+            MaxHappiness = element.GetAttributeFloat("maxhappiness", 100.0f);
+            MaxHunger = element.GetAttributeFloat("maxhunger", 100.0f);
+
+            Happiness = MaxHappiness * 0.5f;
+            Hunger = MaxHunger * 0.5f;
+
+            HappinessDecreaseRate = element.GetAttributeFloat("happinessdecreaserate", 0.1f);
+            HungerIncreaseRate = element.GetAttributeFloat("hungerincreaserate", 0.25f);
+
+            PlayForce = element.GetAttributeFloat("playforce", 15.0f);
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.LocalName.ToLowerInvariant())
+                {
+                    case "itemproduction":
+                        itemsToProduce.Add(new ItemProduction(subElement));
+                        break;
+                    case "eat":
+                        Food food = new Food
+                        {
+                            Tag = subElement.GetAttributeString("tag", ""),
+                            Hunger = subElement.GetAttributeFloat("hunger", -1),
+                            Happiness = subElement.GetAttributeFloat("happiness", 1),
+                            Priority = subElement.GetAttributeFloat("priority", 100),
+                            IgnoreContained = subElement.GetAttributeBool("ignorecontained", true)
+                        };
+                        string[] requiredHungerStr = subElement.GetAttributeString("requiredhunger", "0-100").Split('-');
+                        food.HungerRange = new Vector2(0, 100);
+                        if (requiredHungerStr.Length >= 2)
+                        {
+                            if (float.TryParse(requiredHungerStr[0], NumberStyles.Any, CultureInfo.InvariantCulture, out float tempF)) { food.HungerRange.X = tempF; }
+                            if (float.TryParse(requiredHungerStr[1], NumberStyles.Any, CultureInfo.InvariantCulture, out tempF)) { food.HungerRange.Y = tempF; }
+                        }
+                        foods.Add(food);
+                        break;
+                }
+            }
+        }
+
+        public StatusIndicatorType GetCurrentStatusIndicatorType()
+        {
+            if (Hunger > MaxHunger * 0.5f) { return StatusIndicatorType.Hungry; }
+            if (Happiness > MaxHappiness * 0.8f) { return StatusIndicatorType.Happy; }
+            if (Happiness < MaxHappiness * 0.25f) { return StatusIndicatorType.Sad; }
+            return StatusIndicatorType.None;
+        }
+
+        public bool OnEat(IEnumerable<string> tags, float amount)
+        {
+            foreach (string tag in tags)
+            {
+               if (OnEat(tag, amount)) { return true; }
+            }
+            return false;
+        }
+
+        public bool OnEat(string tag, float amount)
+        {
+            for (int i = 0; i < foods.Count; i++)
+            {
+                if (tag.Equals(foods[i].Tag, System.StringComparison.OrdinalIgnoreCase))
+                {
+                    Hunger += foods[i].Hunger * amount;
+                    Happiness += foods[i].Happiness * amount;
+#if CLIENT
+                    AiController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.5f);
+#endif
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void Play(Character player)
+        {
+            if (PlayTimer > 0.0f) { return; }
+            if (Owner == null) { Owner = player; }
+            PlayTimer = 5.0f;
+            AiController.Character.IsRagdolled = true;
+            Happiness += 10.0f;
+            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()
+        {
+            if (AiController.Character.Inventory != null)
+            {
+                var items = AiController.Character.Inventory.Items;
+                for (int i = 0; i < items.Length; i++)
+                {
+                    var item = items[i];
+                    if (item == null) { continue; }
+                    var tag = item.GetComponent<NameTag>();
+                    if (tag != null && !string.IsNullOrWhiteSpace(tag.WrittenName))
+                    {
+                        return tag.WrittenName;
+                    }
+                }
+            }
+
+            return string.Empty;
+        }
+
+        public void Update(float deltaTime)
+        {
+            var character = AiController.Character;
+            if (character?.Removed ?? true || character.IsDead) { return; }
+
+            if (unstunY.HasValue)
+            {
+                if (PlayTimer > 4.0f)
+                {
+                    float extent = character.AnimController.MainLimb.body.GetMaxExtent();
+                    if (character.SimPosition.Y < (unstunY.Value + extent * 3.0f) &&
+                        character.AnimController.MainLimb.body.LinearVelocity.Y < 0.0f)
+                    {
+                        character.IsRagdolled = false;
+                        unstunY = null;
+                    }
+                    else
+                    {
+                        character.IsRagdolled = true;
+                    }
+                }
+                else
+                {
+                    character.IsRagdolled = false;
+                    unstunY = null;
+                }
+            }
+
+            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];
+                if (Hunger >= food.HungerRange.X && Hunger <= food.HungerRange.Y)
+                {
+                    if (food.TargetParams == null &&
+                        AiController.AIParams.TryAddNewTarget(food.Tag, AIState.Eat, food.Priority, out CharacterParams.TargetParams targetParams))
+                    {
+                        targetParams.IgnoreContained = food.IgnoreContained;
+                        food.TargetParams = targetParams;
+                    }
+                }
+                else if (food.TargetParams != null)
+                {
+                    AiController.AIParams.RemoveTarget(food.TargetParams);
+                    food.TargetParams = null;
+                }
+            }
+
+            if (Hunger >= MaxHunger * 0.99f)
+            {
+                character.CharacterHealth.ApplyAffliction(character.AnimController.MainLimb, new Affliction(AfflictionPrefab.InternalDamage, 8.0f * deltaTime));
+            }
+            else if (Hunger < MaxHunger * 0.1f)
+            {
+                character.CharacterHealth.ReduceAffliction(null, null, 8.0f * deltaTime);
+            }
+
+            if (character.SelectedBy != null)
+            {
+                character.IsRagdolled = true;
+                unstunY = character.SimPosition.Y;
+            }
+
+            for (int i = 0; i < itemsToProduce.Count; i++)
+            {
+                itemsToProduce[i].Update(this, deltaTime);
+            }
+        }
+
+        public static void SavePets(XElement petsElement)
+        {
+            foreach (Character c in Character.CharacterList)
+            {
+                if (!c.IsPet || c.IsDead) { continue; }
+                if (c.Submarine == null) { continue; }
+
+                var petBehavior = (c.AIController as EnemyAIController)?.PetBehavior;
+                if (petBehavior == null) { continue; }
+
+                XElement petElement = new XElement("pet", 
+                    new XAttribute("speciesname", c.SpeciesName), 
+                    new XAttribute("ownerid", petBehavior.Owner?.ID ?? Entity.NullEntityID),
+                    new XAttribute("seed", c.Seed));
+
+                var petBehaviorElement = new XElement("petbehavior",
+                    new XAttribute("hunger", petBehavior.Hunger.ToString("G", CultureInfo.InvariantCulture)),
+                    new XAttribute("happiness", petBehavior.Happiness.ToString("G", CultureInfo.InvariantCulture)));
+                petElement.Add(petBehaviorElement);
+
+                var healthElement = new XElement("health");
+                c.CharacterHealth.Save(healthElement);
+                petElement.Add(healthElement);
+
+                if (c.Inventory != null)
+                {
+                    var inventoryElement = new XElement("inventory");
+                    c.SaveInventory(c.Inventory, inventoryElement);
+                    petElement.Add(inventoryElement);
+                }
+
+                petsElement.Add(petElement);
+            }
+        }
+
+        public static void LoadPets(XElement petsElement)
+        {
+            foreach (XElement subElement in petsElement.Elements())
+            {
+                string speciesName = subElement.GetAttributeString("speciesname", "");
+                string seed = subElement.GetAttributeString("seed", "123");
+                ushort ownerID = (ushort)subElement.GetAttributeInt("ownerid", 0);
+                Vector2 spawnPos = Vector2.Zero;
+                Character owner = Entity.FindEntityByID(ownerID) as Character;
+                if (owner != null)
+                {
+                    spawnPos = owner.WorldPosition;
+                }
+                else
+                {
+                    var spawnPoint = WayPoint.WayPointList.Where(wp => wp.SpawnType == SpawnType.Human && wp.Submarine?.Info.Type == SubmarineType.Player).GetRandom();
+                    spawnPos = spawnPoint?.WorldPosition ?? Submarine.MainSub.WorldPosition;
+                }
+                var pet = Character.Create(speciesName, spawnPos, seed);
+                var petBehavior = (pet.AIController as EnemyAIController)?.PetBehavior;
+                if (petBehavior != null)
+                {
+                    petBehavior.Owner = owner;
+                    var petBehaviorElement = subElement.Attribute("petbehavior");
+                    if (petBehaviorElement != null)
+                    {
+                        petBehavior.Hunger = petBehaviorElement.GetAttributeFloat(50.0f);
+                        petBehavior.Happiness = petBehaviorElement.GetAttributeFloat(50.0f);
+                    }
+                }
+            }
+        }
+
+        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);
+        }
+    }
+}