(1ac786058) AIObjectiveRescueAll now inherits AIObjectiveLoop. Implement reporting on rescue targets. Fix reporting not checking that the targets were in the current hull.

2019-05-16 05:39:07 +03:00
parent b3e9910f4f
commit c583181e3b
13 changed files with 312 additions and 285 deletions
@@ -265,6 +265,7 @@ namespace Barotrauma

                foreach (Item item in Item.ItemList)
                {
+                    if (item.CurrentHull != Character.CurrentHull) { continue; }
                    if (AIObjectiveRepairItems.IsValidTarget(item))
                    {
                        var orderPrefab = Order.PrefabList.Find(o => o.AITag == "reportbrokendevices");
@@ -275,6 +276,7 @@ namespace Barotrauma

                foreach (Character c in Character.CharacterList)
                {
+                    if (c.CurrentHull != Character.CurrentHull) { continue; }
                    if (AIObjectiveFightIntruders.IsValidTarget(c))
                    {
                        var orderPrefab = Order.PrefabList.Find(o => o.AITag == "reportintruders");
@@ -283,11 +285,11 @@ namespace Barotrauma
                    }
                }

-                // TODO: the objective needs to inherit AIObjectiveLoop<T>
                if (Character.Bleeding > 1.0f || Character.Vitality < Character.MaxVitality * 0.1f)
                {
                    var orderPrefab = Order.PrefabList.Find(o => o.AITag == "requestfirstaid");
                    newOrder = new Order(orderPrefab, Character.CurrentHull, null);
+                    AddTargets<AIObjectiveRescueAll, Character>(Character, Character);
                }
            }

@@ -490,6 +492,7 @@ namespace Barotrauma
                case "reportbrokendevices":
                    foreach (var item in Item.ItemList)
                    {
+                        if (item.CurrentHull != hull) { continue; }
                        if (AIObjectiveRepairItems.IsValidTarget(item))
                        {
                            AddTargets<AIObjectiveRepairItems, Item>(character, item);
@@ -499,6 +502,7 @@ namespace Barotrauma
                case "reportintruders":
                    foreach (var enemy in Character.CharacterList)
                    {
+                        if (enemy.CurrentHull != hull) { continue; }
                        if (AIObjectiveFightIntruders.IsValidTarget(enemy))
                        {
                            AddTargets<AIObjectiveFightIntruders, Character>(character, enemy);
@@ -506,8 +510,19 @@ namespace Barotrauma
                    }
                    break;
                case "requestfirstaid":
-                    // TODO
+                    foreach (var c in Character.CharacterList)
+                    {
+                        if (c.CurrentHull != hull) { continue; }
+                        if (AIObjectiveRescueAll.IsValidTarget(c))
+                        {
+                            AddTargets<AIObjectiveRescueAll, Character>(character, c);
+                        }
+                    }
+                    break;
                default:
+#if DEBUG
+                    DebugConsole.ThrowError(order.AITag + " not implemented!");
+#endif
                    break;
            }
        }
@@ -773,6 +773,49 @@ namespace Barotrauma
                {
                    character.AIController.SteeringManager.Reset();
                }
+                if (goToObjective != null) { return; }
+                if (currentHull == null) { return; }
+                //goto objective doesn't exist (a safe hull not found, or a path to a safe hull not found)
+                // -> attempt to manually steer away from hazards
+                Vector2 escapeVel = Vector2.Zero;
+                foreach (FireSource fireSource in currentHull.FireSources)
+                {
+                    Vector2 dir = character.Position - fireSource.Position;
+                    float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(fireSource.Position, character.Position), 0.1f, 10.0f);
+                    escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
+                }
+                foreach (Character enemy in Character.CharacterList)
+                {
+                    //don't run from friendly NPCs
+                    if (enemy.TeamID == Character.TeamType.FriendlyNPC) { continue; }
+                    //friendly NPCs don't run away from anything but characters controlled by EnemyAIController (= monsters)
+                    if (character.TeamID == Character.TeamType.FriendlyNPC && !(enemy.AIController is EnemyAIController)) { continue; }
+                    if (enemy.CurrentHull == currentHull && !enemy.IsDead && !enemy.IsUnconscious &&
+                        (enemy.AIController is EnemyAIController || enemy.TeamID != character.TeamID))
+                    {
+                        Vector2 dir = character.Position - enemy.Position;
+                        float distMultiplier = MathHelper.Clamp(100.0f / Vector2.Distance(enemy.Position, character.Position), 0.1f, 10.0f);
+                        escapeVel += new Vector2(Math.Sign(dir.X) * distMultiplier, !character.IsClimbing ? 0 : Math.Sign(dir.Y) * distMultiplier);
+                    }
+                }
+                if (escapeVel != Vector2.Zero)
+                {
+                    //only move if we haven't reached the edge of the room
+                    if ((escapeVel.X < 0 && character.Position.X > currentHull.Rect.X + 50) ||
+                        (escapeVel.X > 0 && character.Position.X < currentHull.Rect.Right - 50))
+                    {
+                        character.AIController.SteeringManager.SteeringManual(deltaTime, escapeVel);
+                    }
+                    else
+                    {
+                        character.AnimController.TargetDir = escapeVel.X < 0.0f ? Direction.Right : Direction.Left;
+                        character.AIController.SteeringManager.Reset();
+                    }
+                }
+                else
+                {
+                    character.AIController.SteeringManager.Reset();
+                }
            }
        }

@@ -446,6 +446,31 @@ namespace Barotrauma
            {
 #if DEBUG
                DebugConsole.ThrowError("AIObjectiveFixLeak failed - the item \"" + weldingTool + "\" has no RepairTool component but is tagged as a welding tool");
+#endif
+                abandon = true;
+                return;
+            }
+            Vector2 gapDiff = Leak.WorldPosition - character.WorldPosition;
+            // TODO: use the collider size/reach?
+            if (!character.AnimController.InWater && Math.Abs(gapDiff.X) < 100 && gapDiff.Y < 0.0f && gapDiff.Y > -150)
+            {
+                HumanAIController.AnimController.Crouching = true;
+            }
+            float reach = ConvertUnits.ToSimUnits(repairTool.Range);
+            bool canOperate = ConvertUnits.ToSimUnits(gapDiff.Length()) < reach;
+            if (canOperate)
+            {
+                TryAddSubObjective(ref operateObjective, () => new AIObjectiveOperateItem(repairTool, character, objectiveManager, option: "", requireEquip: true, operateTarget: Leak));
+            }
+            else
+            {
+                TryAddSubObjective(ref gotoObjective, () => new AIObjectiveGoTo(ConvertUnits.ToSimUnits(GetStandPosition()), character, objectiveManager) { CloseEnough = reach * 0.75f });
+            }
+            var repairTool = weldingTool.GetComponent<RepairTool>();
+            if (repairTool == null)
+            {
+#if DEBUG
+                DebugConsole.ThrowError("AIObjectiveFixLeak failed - the item \"" + weldingTool + "\" has no RepairTool component but is tagged as a welding tool");
 #endif
                abandon = true;
                return;
@@ -74,6 +74,21 @@ namespace Barotrauma
            }
        }

+        public override void Update(float deltaTime)
+        {
+            if (objectiveManager.CurrentObjective == this)
+            {
+                if (randomTimer > 0)
+                {
+                    randomTimer -= deltaTime;
+                }
+                else
+                {
+                    SetRandom();
+                }
+            }
+        }
+
        public override bool IsCompleted() => false;
        public override bool CanBeCompleted => true;

@@ -155,6 +155,10 @@ namespace Barotrauma
                    {
                        isCompleted = true;
                    }
+                    if (component.AIOperate(deltaTime, character, this))
+                    {
+                        isCompleted = true;
+                    }
                }
                else
                {
@@ -1,67 +1,49 @@
 using System.Collections.Generic;
 using System.Linq;
+using Barotrauma.Extensions;

 namespace Barotrauma
 {
-    // TODO: Refactor using AIObjectiveLoop class.
-    class AIObjectiveRescueAll : AIObjective
+    class AIObjectiveRescueAll : AIObjectiveLoop<Character>
    {
        public override string DebugTag => "rescue all";

        //only treat characters whose vitality is below this (0.8 = 80% of max vitality)
        public const float VitalityThreshold = 0.8f;
-
-        private List<Character> rescueTargets;
        
-        public AIObjectiveRescueAll(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1) : base(character, objectiveManager, priorityModifier)
+        public AIObjectiveRescueAll(Character character, AIObjectiveManager objectiveManager, float priorityModifier = 1) 
+            : base(character, objectiveManager, priorityModifier) { }
+
+        public override bool IsDuplicate(AIObjective otherObjective) => otherObjective is AIObjectiveRescueAll;
+
+        protected override void FindTargets()
        {
-            rescueTargets = new List<Character>();
+            base.FindTargets();
+            if (targets.None() && objectiveManager.CurrentOrder == this)
+            {
+                character.Speak(TextManager.Get("DialogNoRescueTargets"), null, 3.0f, "norescuetargets", 30.0f);
+            }
        }

-        public override bool IsDuplicate(AIObjective otherObjective)
+        protected override bool Filter(Character target)
        {
+            if (target == null || target.IsDead || target.Removed) { return false; }
+            if (target == character) { return false; }
+            if (target.Submarine != character.Submarine) { return false; }
+            if (target.CurrentHull == null && character.Submarine != null) { return false; }
+            if (target.Vitality / target.MaxVitality > VitalityThreshold) { return false; }
+            if (HumanAIController == null || !HumanAIController.IsFriendly(target)) { return false; }
            return true;
        }

-        public override float GetPriority()
+        protected override IEnumerable<Character> GetList() => Character.CharacterList;
+
+        protected override AIObjective ObjectiveConstructor(Character target) => new AIObjectiveRescue(character, target, objectiveManager, PriorityModifier);
+
+        protected override float TargetEvaluation()
        {
-            // TODO: review
-            if (character.Submarine == null) { return 0; }
-            GetRescueTargets();
-            if (!rescueTargets.Any()) { return 0.0f; }
-            
-            if (objectiveManager.CurrentOrder == this)
-            {
-                return AIObjectiveManager.OrderPriority;
-            }
-
-            //if there are targets to rescue, the priority is slightly less 
-            //than the priority of explicit orders given to the character
-            return AIObjectiveManager.OrderPriority - 5.0f;
+            // TODO: sorting criteria
+            return 100;
        }
-
-        private void GetRescueTargets()
-        {
-            rescueTargets = Character.CharacterList.FindAll(c => 
-                c.AIController is HumanAIController &&
-                c.TeamID == character.TeamID &&
-                c != character &&
-                !c.IsDead &&
-                HumanAIController.IsFriendly(c) &&
-                c.Vitality / c.MaxVitality < VitalityThreshold);
-        }
-
-        protected override void Act(float deltaTime)
-        {
-            foreach (Character target in rescueTargets)
-            {
-                AddSubObjective(new AIObjectiveRescue(character, target, objectiveManager));
-            }
-        }
-
-        public override bool IsCompleted() => false;
-        public override bool CanBeCompleted => true;
-
-        public override bool IsLoop { get => true; set => throw new System.Exception("Trying to set the value for IsLoop from: " + System.Environment.StackTrace); }
    }
 }
@@ -696,6 +696,25 @@ namespace Barotrauma.Items.Components
                    }
                }
                
+                if (targetItem.Prefab.DeconstructItems.Any())
+                {
+                    inputContainer.Inventory.RemoveItem(targetItem);
+                    Entity.Spawner.AddToRemoveQueue(targetItem);
+                    MoveInputQueue();
+                    PutItemsToLinkedContainer();
+                }
+                else
+                {
+                    if (outputContainer.Inventory.Items.All(i => i != null))
+                    {
+                        targetItem.Drop(dropper: null);
+                    }
+                    else
+                    {
+                        outputContainer.Inventory.TryPutItem(targetItem, user: null, createNetworkEvent: true);
+                    }
+                }
+                
                if (targetItem.Prefab.DeconstructItems.Any())
                {
                    inputContainer.Inventory.RemoveItem(targetItem);
@@ -212,6 +212,33 @@ namespace Barotrauma.Items.Components
            }
        }

+        public Vector2? PosToMaintain
+        {
+            get { return posToMaintain; }
+            set { posToMaintain = value; }
+        }
+
+        struct ObstacleDebugInfo
+        {
+            public Vector2 Point1;
+            public Vector2 Point2;
+
+            public Vector2? Intersection;
+
+            public float Dot;
+
+            public Vector2 AvoidStrength;
+
+            public ObstacleDebugInfo(GraphEdge edge, Vector2? intersection, float dot, Vector2 avoidStrength)
+            {
+                Point1 = edge.Point1;
+                Point2 = edge.Point2;
+                Intersection = intersection;
+                Dot = dot;
+                AvoidStrength = avoidStrength;
+            }
+        }
+
        //edge point 1, edge point 2, avoid strength
        private List<ObstacleDebugInfo> debugDrawObstacles = new List<ObstacleDebugInfo>();

@@ -1548,6 +1548,10 @@ namespace Barotrauma
            {
                ApplyStatusEffects(!waterProof && inWater ? ActionType.InWater : ActionType.NotInWater, deltaTime);
            }
+            if (!broken)
+            {
+                ApplyStatusEffects(!waterProof && inWater ? ActionType.InWater : ActionType.NotInWater, deltaTime);
+            }
            ApplyStatusEffects(!waterProof && inWater ? ActionType.InWater : ActionType.NotInWater, deltaTime);

            if (body == null || !body.Enabled || !inWater || ParentInventory != null || Removed) { return; }
@@ -417,6 +417,25 @@ namespace Barotrauma
            }
        }

+        public string DisplayName
+        {
+            get;
+            private set;
+        }
+
+        private string roomName;
+        [Editable, Serialize("", true, translationTextTag: "RoomName.")]
+        public string RoomName
+        {
+            get { return roomName; }
+            set
+            {
+                if (roomName == value) { return; }
+                roomName = value;
+                DisplayName = TextManager.Get(roomName, returnNull: true) ?? roomName;
+            }
+        }
+
        public override Rectangle Rect
        {
            get