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

2023-12-14 11:56:39 -03:00
parent 283d9db518 7f295c291e
commit 448e4cdfbb
376 changed files with 7775 additions and 2879 deletions
@@ -197,17 +197,6 @@ namespace Barotrauma
            }
        }

-        /// <summary>
-        /// This method allows multiple subobjectives of same type. Use with caution.
-        /// </summary>
-        public void AddSubObjectiveInQueue(AIObjective objective)
-        {
-            if (!subObjectives.Contains(objective))
-            {
-                subObjectives.Add(objective);
-            }
-        }
-
        public void RemoveSubObjective<T>(ref T objective) where T : AIObjective
        {
            if (objective != null)
@@ -0,0 +1,160 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveCheckStolenItems : AIObjective
+    {
+        public override Identifier Identifier { get; set; } = "check stolen items".ToIdentifier();
+        public override bool AllowOutsideSubmarine => false;
+        public override bool AllowInAnySub => false;
+
+        public float FindStolenItemsProbability = 1.0f;
+
+        enum State
+        {
+            GotoTarget,
+            Inspect, 
+            Warn,
+            Done
+        }
+
+        private float inspectDelay;
+        private float warnDelay;
+
+        private State currentState;
+
+        public readonly Character TargetCharacter;
+
+        private AIObjectiveGoTo? goToObjective;
+
+        private readonly List<Item> stolenItems = new List<Item>();
+
+        public AIObjectiveCheckStolenItems(Character character, Character targetCharacter, AIObjectiveManager objectiveManager, float priorityModifier = 1) : 
+            base(character, objectiveManager, priorityModifier)
+        {
+            TargetCharacter = targetCharacter;
+            inspectDelay = 5.0f;
+            warnDelay = 5.0f;
+        }
+
+        public override bool IsLoop 
+        { 
+            get => false; 
+            set => throw new Exception("Trying to set the value for IsLoop from: " + Environment.StackTrace.CleanupStackTrace()); 
+        }
+        
+        protected override bool CheckObjectiveSpecific() => false;
+
+        protected override float GetPriority()
+        {
+            if (!Abandon && !IsCompleted && objectiveManager.IsOrder(this))
+            {
+                Priority = objectiveManager.GetOrderPriority(this);
+            }
+            else
+            {
+                Priority = AIObjectiveManager.LowestOrderPriority - 1;
+            }
+            return Priority;
+        }
+
+        public void ForceComplete()
+        {
+            IsCompleted = true;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            switch (currentState)
+            {
+                case State.GotoTarget:
+                    TryAddSubObjective(ref goToObjective,
+                    constructor: () =>
+                    {
+                        return new AIObjectiveGoTo(TargetCharacter, character, objectiveManager, repeat: false)
+                        {
+                            SpeakIfFails = false
+                        };
+                    },
+                    onCompleted: () =>
+                    {
+                        RemoveSubObjective(ref goToObjective);
+                        currentState = State.Inspect;
+                        stolenItems.Clear();
+                        TargetCharacter.Inventory.FindAllItems(it => it.SpawnedInCurrentOutpost && !it.AllowStealing, recursive: true, stolenItems);
+                        character.Speak(TextManager.Get("dialogcheckstolenitems").Value);
+                    },
+                    onAbandon: () =>
+                    {
+                        Abandon = true;
+                    });
+                    break;
+                case State.Inspect:
+                    Inspect(deltaTime);
+                    break;
+                case State.Warn:
+                    Warn(deltaTime);
+                    break;
+            }
+        }
+
+        private void Inspect(float deltaTime)
+        {
+            if (inspectDelay > 0.0f)
+            {
+                character.SelectCharacter(TargetCharacter);
+                inspectDelay -= deltaTime;
+                return;
+            }
+
+            if (stolenItems.Any() &&
+                Rand.Range(0.0f, 1.0f, Rand.RandSync.Unsynced) < FindStolenItemsProbability)
+            {
+                character.Speak(TextManager.Get("dialogcheckstolenitems.warn").Value);
+                currentState = State.Warn;
+            }
+            else
+            {
+                character.Speak(TextManager.Get("dialogcheckstolenitems.nostolenitems").Value);
+                currentState = State.Done;
+                IsCompleted = true;
+            }
+            character.DeselectCharacter();
+        }
+
+        private void Warn(float deltaTime)
+        {
+            if (warnDelay > 0.0f)
+            {
+                warnDelay -= deltaTime;
+                return;
+            }
+            var stolenItemsOnCharacter = stolenItems.Where(it => it.GetRootInventoryOwner() == TargetCharacter);
+            if (stolenItemsOnCharacter.Any())
+            {
+                character.Speak(TextManager.Get("dialogcheckstolenitems.arrest").Value);
+                HumanAIController.AddCombatObjective(AIObjectiveCombat.CombatMode.Arrest, TargetCharacter);
+                foreach (var stolenItem in stolenItemsOnCharacter)
+                {
+                    HumanAIController.ApplyStealingReputationLoss(stolenItem);
+                }
+            }
+            else
+            {
+                character.Speak(TextManager.Get("dialogcheckstolenitems.comply").Value);
+            }
+            foreach (var item in stolenItems)
+            {
+                HumanAIController.ObjectiveManager.AddObjective(new AIObjectiveGetItem(character, item, objectiveManager, equip: false)
+                {
+                    BasePriority = 10
+                });
+            }                
+            currentState = State.Done;
+            IsCompleted = true;
+        }
+    }
+}
@@ -1070,7 +1070,8 @@ namespace Barotrauma
            {
                // Try reload ammunition from inventory
                static bool IsInsideHeadset(Item i) => i.ParentInventory?.Owner is Item ownerItem && ownerItem.HasTag(Tags.MobileRadio);
-                Item ammunition = character.Inventory.FindItem(i => i.HasIdentifierOrTags(ammunitionIdentifiers) && i.Condition > 0 && !IsInsideHeadset(i), recursive: true);
+                Item ammunition = character.Inventory.FindItem(i => 
+                    i.HasIdentifierOrTags(ammunitionIdentifiers) && i.Condition > 0 && !IsInsideHeadset(i) && i.IsInteractable(character), recursive: true);
                if (ammunition != null)
                {
                    var container = Weapon.GetComponent<ItemContainer>();
@@ -1089,6 +1090,9 @@ namespace Barotrauma
            }
            else if (!HoldPosition && IsOffensiveOrArrest && seekAmmo && ammunitionIdentifiers != null)
            {
+                // Inventory not drawn = it's not interactable
+                // If the weapon is empty and the inventory is inaccessible, it can't be reloaded
+                if (!Weapon.OwnInventory.Container.DrawInventory) { return false; }
                SeekAmmunition(ammunitionIdentifiers);
            }
            return false;
@@ -14,7 +14,7 @@ namespace Barotrauma
        private int escapeProgress;
        private bool isBeingWatched;

-        private bool shouldSwitchTeams;
+        private readonly bool shouldSwitchTeams;

        const string EscapeTeamChangeIdentifier = "escape";

@@ -88,10 +88,12 @@ namespace Barotrauma
                escapeProgress += Rand.Range(2, 5);
                if (escapeProgress > 15)
                {
-                    Item handcuffs = character.Inventory.FindItemByTag(Tags.HandLockerItem);
-                    if (handcuffs != null)
+                    foreach (var it in character.HeldItems)
                    {
-                        handcuffs.Drop(character);
+                        if (it.HasTag(Tags.HandLockerItem) && it.IsInteractable(character))
+                        {
+                            it.Drop(character);
+                        }
                    }
                }
                escapeTimer = EscapeIntervalTimer * Rand.Range(0.75f, 1.25f);
@@ -0,0 +1,152 @@
+#nullable enable
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveFindThieves : AIObjectiveLoop<Character>
+    {
+        public override Identifier Identifier { get; set; } = "find thieves".ToIdentifier();
+        protected override float IgnoreListClearInterval => 30;
+        public override bool IgnoreUnsafeHulls => true;
+
+        protected override float TargetUpdateTimeMultiplier => 1.0f;
+
+        const float DefaultInspectDistance = 200.0f;
+
+        /// <summary>
+        /// How close the NPC must be to the target to the inspect them? You can use high values to make the NPC 
+        /// systematically go through targets no matter where they are, and low values to check targets they happen to come across.
+        /// </summary>
+        public float InspectDistance = DefaultInspectDistance;
+
+        private float? overrideInspectProbability;
+        /// <summary>
+        /// Chance of inspecting a valid target. The NPC won't try to inspect that target again for <see cref="inspectionInterval"/> 
+        /// regardless if the target is inspected or not.
+        /// </summary>
+        public float InspectProbability
+        {
+            get
+            {
+                if (overrideInspectProbability.HasValue)
+                {
+                    return overrideInspectProbability.Value;
+                }
+                if (GameMain.GameSession?.Campaign is { } campaign)
+                {
+                    if (campaign.Map?.CurrentLocation?.Reputation is { } reputation)
+                    {
+                        return MathHelper.Lerp(
+                            campaign.Settings.MaxStolenItemInspectionProbability,
+                            campaign.Settings.MinStolenItemInspectionProbability, 
+                            reputation.NormalizedValue);
+                    }
+                }
+
+                return 0.2f;
+            }
+        }
+
+        /// <summary>
+        /// When did the character last inspect whether some other character has stolen items on them?
+        /// </summary>
+        private static readonly Dictionary<Character, double> lastInspectionTimes = new Dictionary<Character, double>();
+
+        private readonly float inspectionInterval = 120.0f;
+
+        public AIObjectiveFindThieves(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1)
+            : base(character, objectiveManager, priorityModifier) { }
+
+        protected override bool Filter(Character target)
+        {
+            if (!IsValidTarget(target, character)) { return false; }
+            if (Vector2.DistanceSquared(target.WorldPosition, character.WorldPosition) > InspectDistance * InspectDistance) { return false; }
+            if (lastInspectionTimes.TryGetValue(target, out double lastInspectionTime))
+            {
+                if (Timing.TotalTime < lastInspectionTime + inspectionInterval)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        protected override IEnumerable<Character> GetList() => Character.CharacterList;
+
+        protected override float TargetEvaluation()
+        {
+            return subObjectives.Any() ? 50 : 0;
+        }
+
+        public void InspectEveryone()
+        {
+            lastInspectionTimes.Clear();
+            overrideInspectProbability = 1.0f;
+            InspectDistance = DefaultInspectDistance * 2;
+        }
+
+        protected override AIObjective ObjectiveConstructor(Character target)
+        {
+            var checkStolenItemsObjective = new AIObjectiveCheckStolenItems(character, target, objectiveManager);
+            if (Rand.Range(0.0f, 1.0f, Rand.RandSync.Unsynced) >= InspectProbability)
+            {
+                checkStolenItemsObjective.ForceComplete();
+                lastInspectionTimes[target] = Timing.TotalTime;
+            }
+            return checkStolenItemsObjective;
+        }
+
+        private float checkVisibleStolenItemsTimer;
+        private const float CheckVisibleStolenItemsInterval = 5.0f;
+
+        public override void Update(float deltaTime)
+        {
+            base.Update(deltaTime);
+            if (checkVisibleStolenItemsTimer > 0.0f)
+            {
+                checkVisibleStolenItemsTimer -= deltaTime;
+                return;
+            }
+            foreach (var target in Character.CharacterList)
+            {
+                if (!IsValidTarget(target, character)) { continue; }
+                //if we spot someone wearing or holding stolen items, immediately check them (with 100% chance of spotting the stolen items)
+                if (target.Inventory.AllItems.Any(it => it.SpawnedInCurrentOutpost && !it.AllowStealing && target.HasEquippedItem(it)) &&
+                    character.CanSeeTarget(target, seeThroughWindows: true))
+                {
+                    AIObjectiveCheckStolenItems? existingObjective = 
+                        objectiveManager.GetActiveObjectives<AIObjectiveCheckStolenItems>().FirstOrDefault(o => o.TargetCharacter == target);
+                    if (existingObjective == null)
+                    {
+                        objectiveManager.AddObjective(new AIObjectiveCheckStolenItems(character, target, objectiveManager));
+                        lastInspectionTimes[target] = Timing.TotalTime;
+                    }
+
+                }
+            }
+            checkVisibleStolenItemsTimer = CheckVisibleStolenItemsInterval;
+        }
+
+        private bool IsValidTarget(Character target, Character character)
+        {
+            if (target == null || target.Removed) { return false; }
+            if (target.IsIncapacitated) { return false; }
+            if (target == character) { return false; }
+            if (target.Submarine == null) { return false; }
+            if (character.Submarine == null) { return false; }
+            if (target.CurrentHull == null) { return false; }
+            if (target.Submarine != character.Submarine) { return false; }
+            //only player's crew can steal, ignore other teams
+            if (!target.IsOnPlayerTeam) { return false; }
+            if (target.IsArrested) { return false; }
+            return true;
+        }
+
+        protected override void OnObjectiveCompleted(AIObjective objective, Character target)
+        {
+            lastInspectionTimes[target] = Timing.TotalTime;
+        }
+    }
+}
@@ -120,7 +120,7 @@ namespace Barotrauma
            // The intention behind this is to reduce unnecessary path finding calls in cases where the bot can't find a path.
            timerMargin += 0.5f;
            timerMargin = Math.Min(timerMargin, newTargetIntervalMin);
-            newTargetTimer = Math.Min(newTargetTimer, timerMargin);
+            newTargetTimer = Math.Max(newTargetTimer, timerMargin);
        }

        private void SetTargetTimerHigh()
@@ -178,7 +178,7 @@ namespace Barotrauma
                if (!objectiveManager.IsOrder(this))
                {
                    // Battery or pump states cannot currently be reported (not implemented) and therefore we must ignore them -> the bots always know if they require attention.
-                    bool ignore = this is AIObjectiveChargeBatteries || this is AIObjectivePumpWater;
+                    bool ignore = this is AIObjectiveChargeBatteries || this is AIObjectivePumpWater || this is AIObjectiveFindThieves;
                    if (!ignore && !ReportedTargets.Contains(target)) { continue; }
                }
                if (!Filter(target)) { continue; }
@@ -151,6 +151,7 @@ namespace Barotrauma
                prevIdleObjective.PreferredOutpostModuleTypes.ForEach(t => newIdleObjective.PreferredOutpostModuleTypes.Add(t));
            }
            AddObjective(newIdleObjective);
+
            int objectiveCount = Objectives.Count;
            foreach (var autonomousObjective in character.Info.Job.Prefab.AutonomousObjectives)
            {
@@ -558,6 +559,9 @@ namespace Barotrauma
                case "escapehandcuffs":
                    newObjective = new AIObjectiveEscapeHandcuffs(character, this, priorityModifier: priorityModifier);
                    break;
+                case "findthieves":
+                    newObjective = new AIObjectiveFindThieves(character, this, priorityModifier: priorityModifier);
+                    break;
                case "prepareforexpedition":
                    newObjective = new AIObjectivePrepare(character, this, order.GetTargetItems(order.Option), order.RequireItems)
                    {