(94ad97066) Refactor combat objective. The bots should now be able to reload and seek more ammunition. When they run out of ammunition, they first try to use another weapon and only if no other weapon is found, they seek more ammunition. Had to change the contain item and get item objectives a bit. Hopefully doesn't break things too much.

2019-05-16 06:13:15 +03:00
parent 298f1a79b0
commit ce7b9c4f52
41 changed files with 634 additions and 348 deletions
@@ -11,9 +11,10 @@ namespace Barotrauma
    class AIObjectiveCombat : AIObjective
    {
        public override string DebugTag => "combat";
-        public bool useCoolDown = true;

-        const float CoolDown = 10.0f;
+        private readonly CombatMode initialMode;
+
+        const float coolDown = 10.0f;

        public Character Enemy { get; private set; }
        
@@ -25,14 +26,7 @@ namespace Barotrauma
            {
                _weapon = value;
                _weaponComponent = null;
-                if (reloadWeaponObjective != null)
-                {
-                    if (subObjectives.Contains(reloadWeaponObjective))
-                    {
-                        subObjectives.Remove(reloadWeaponObjective);
-                    }
-                    reloadWeaponObjective = null;
-                }
+                RemoveSubObjective(ref seekAmmunition);
            }
        }
        private ItemComponent _weaponComponent;
@@ -40,6 +34,7 @@ namespace Barotrauma
        {
            get
            {
+                if (Weapon == null) { return null; }
                if (_weaponComponent == null)
                {
                    _weaponComponent =
@@ -58,12 +53,14 @@ namespace Barotrauma
        private readonly HashSet<MeleeWeapon> meleeWeapons = new HashSet<MeleeWeapon>();
        private readonly HashSet<Item> adHocWeapons = new HashSet<Item>();

-        private AIObjectiveContainItem reloadWeaponObjective;
+        private AIObjectiveContainItem seekAmmunition;
        private AIObjectiveGoTo retreatObjective;
        private AIObjectiveGoTo followTargetObjective;

        private Hull retreatTarget;
        private float coolDownTimer;
+        private IEnumerable<FarseerPhysics.Dynamics.Body> myBodies;
+        private float aimTimer;

        public enum CombatMode
        {
@@ -78,7 +75,7 @@ namespace Barotrauma
            : base(character, objectiveManager, priorityModifier)
        {
            Enemy = enemy;
-            coolDownTimer = CoolDown;
+            coolDownTimer = coolDown;
            findSafety = objectiveManager.GetObjective<AIObjectiveFindSafety>();
            if (findSafety != null)
            {
@@ -86,6 +83,7 @@ namespace Barotrauma
                findSafety.unreachable.Clear();
            }
            Mode = mode;
+            initialMode = Mode;
            if (Enemy == null)
            {
                Mode = CombatMode.Retreat;
@@ -104,7 +102,7 @@ namespace Barotrauma

        public override bool IsCompleted()
        {
-            bool completed = (Enemy != null && (Enemy.Removed || Enemy.IsDead)) || (useCoolDown && coolDownTimer <= 0);
+            bool completed = (Enemy != null && (Enemy.Removed || Enemy.IsDead)) || (initialMode != CombatMode.Offensive && coolDownTimer <= 0);
            if (completed)
            {
                if (objectiveManager.CurrentOrder == this && Enemy != null && Enemy.IsDead)
@@ -121,65 +119,93 @@ namespace Barotrauma

        protected override void Act(float deltaTime)
        {
-            if (useCoolDown)
+            if (initialMode != CombatMode.Offensive)
            {
                coolDownTimer -= deltaTime;
            }
            if (abandon) { return; }
-            Arm(deltaTime);
-            Move(deltaTime);
+            TryArm();
+            if (seekAmmunition == null || !subObjectives.Contains(seekAmmunition))
+            {
+                Move();
+                if (Weapon != null)
+                {
+                    OperateWeapon(deltaTime);
+                }
+            }
        }

-        private void Arm(float deltaTime)
+        private void Move()
        {
            switch (Mode)
            {
                case CombatMode.Offensive:
+                    Engage();
+                    break;
                case CombatMode.Defensive:
-                    if (Weapon != null && !character.Inventory.Items.Contains(_weapon) || _weaponComponent != null && !_weaponComponent.HasRequiredContainedItems(false))
+                case CombatMode.Retreat:
+                    Retreat();
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+
+        private bool TryArm()
+        {
+            if (Weapon != null)
+            {
+                if (!character.Inventory.Items.Contains(Weapon) || WeaponComponent == null)
+                {
+                    Weapon = null;
+                }
+                else if (!WeaponComponent.HasRequiredContainedItems(false))
+                {
+                    // Seek ammunition only if cannot find a new weapon
+                    if (!Reload(true, () => GetWeapon() == null))
                    {
-                        Weapon = null;
-                    }
-                    if (Weapon == null)
-                    {
-                        Weapon = GetWeapon();
-                    }
-                    if (Weapon == null)
-                    {
-                        Mode = CombatMode.Retreat;
-                    }
-                    if (Equip())
-                    {
-                        if (Reload(deltaTime))
+                        if (seekAmmunition != null && subObjectives.Contains(seekAmmunition))
                        {
-                            Attack(deltaTime);
+                            return false;
+                        }
+                        else
+                        {
+                            Weapon = null;
                        }
                    }
-                    break;
-                case CombatMode.Retreat:
-                    break;
-                default:
-                    throw new NotImplementedException();
+                }
            }
+            if (Weapon == null)
+            {
+                Weapon = GetWeapon();
+            }
+            if (Weapon == null)
+            {
+                Weapon = GetWeapon(ignoreRequiredItems: true);
+            }
+            Mode = Weapon == null ? CombatMode.Retreat : initialMode;
+            return Weapon != null;
        }

-        private void Move(float deltaTime)
+        private void OperateWeapon(float deltaTime)
        {
            switch (Mode)
            {
                case CombatMode.Offensive:
-                    Engage(deltaTime);
-                    break;
                case CombatMode.Defensive:
+                    if (Equip())
+                    {
+                        Attack(deltaTime);
+                    }
+                    break;
                case CombatMode.Retreat:
-                    Retreat(deltaTime);
                    break;
                default:
                    throw new NotImplementedException();
            }
        }

-        private Item GetWeapon()
+        private Item GetWeapon(bool ignoreRequiredItems = false)
        {
            rangedWeapons.Clear();
            meleeWeapons.Clear();
@@ -193,14 +219,14 @@ namespace Barotrauma
                {
                    if (component is RangedWeapon rw)
                    {
-                        if (rw.HasRequiredContainedItems(false))
+                        if (ignoreRequiredItems || rw.HasRequiredContainedItems(false))
                        {
                            rangedWeapons.Add(rw);
                        }
                    }
                    else if (component is MeleeWeapon mw)
                    {
-                        if (mw.HasRequiredContainedItems(false))
+                        if (ignoreRequiredItems || mw.HasRequiredContainedItems(false))
                        {
                            meleeWeapons.Add(mw);
                        }
@@ -216,7 +242,7 @@ namespace Barotrauma
                                {
                                    if (statusEffect.Afflictions.Any())
                                    {
-                                        if (component.HasRequiredContainedItems(false))
+                                        if (ignoreRequiredItems || component.HasRequiredContainedItems(false))
                                        {
                                            adHocWeapons.Add(item);
                                        }
@@ -253,19 +279,29 @@ namespace Barotrauma
                    Weapon.Drop(character);
                }
            }
+            return true;
        }

        private bool Equip()
        {
-            if (!character.SelectedItems.Contains(Weapon))
+            if (!WeaponComponent.HasRequiredContainedItems(false))
            {
+                Mode = CombatMode.Retreat;
+                return false;
+            }
+            //if (!character.SelectedItems.Contains(Weapon))
+            if (!character.HasEquippedItem(Weapon))
+            {
+                Weapon.TryInteract(character, forceSelectKey: true);
                var slots = Weapon.AllowedSlots.FindAll(s => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand));
                if (character.Inventory.TryPutItem(Weapon, character, slots))
                {
                    Weapon.Equip(character);
+                    aimTimer = Rand.Range(0.5f, 1f);
                }
                else
                {
+                    Weapon = null;
                    Mode = CombatMode.Retreat;
                    return false;
                }
@@ -273,16 +309,10 @@ namespace Barotrauma
            return true;
        }

-        private void Retreat(float deltaTime)
+        private void Retreat()
        {
-            if (followTargetObjective != null)
-            {
-                if (subObjectives.Contains(followTargetObjective))
-                {
-                    subObjectives.Remove(followTargetObjective);
-                }
-                followTargetObjective = null;
-            }
+            RemoveSubObjective(ref followTargetObjective);
+            RemoveSubObjective(ref seekAmmunition);
            if (retreatObjective != null && retreatObjective.Target != retreatTarget)
            {
                retreatObjective = null;
@@ -294,59 +324,115 @@ namespace Barotrauma
            TryAddSubObjective(ref retreatObjective, () => new AIObjectiveGoTo(retreatTarget, character, objectiveManager, false, true));
        }

-        private void Engage(float deltaTime)
+        private void Engage()
        {
            retreatTarget = null;
-            if (retreatObjective != null)
+            RemoveSubObjective(ref retreatObjective);
+            RemoveSubObjective(ref seekAmmunition);
+            if (followTargetObjective != null && followTargetObjective.Target != Enemy)
            {
-                if (subObjectives.Contains(retreatObjective))
-                {
-                    subObjectives.Remove(retreatObjective);
-                }
-                retreatObjective = null;
+                followTargetObjective = null;
            }
            TryAddSubObjective(ref followTargetObjective,
                constructor: () => new AIObjectiveGoTo(Enemy, character, objectiveManager, repeat: true, getDivingGearIfNeeded: true)
                {
                    AllowGoingOutside = true,
                    IgnoreIfTargetDead = true,
-                    CheckVisibility = true,
-                    CloseEnough =
-                        WeaponComponent is RangedWeapon ? 3 :
-                        WeaponComponent is MeleeWeapon mw ? ConvertUnits.ToSimUnits(mw.Range) :
-                        WeaponComponent is RepairTool rt ? ConvertUnits.ToSimUnits(rt.Range) : 0.5f
+                    CheckVisibility = true
                },
                onAbandon: () =>
                {
-                    SteeringManager.Reset();
                    Mode = CombatMode.Retreat;
+                    SteeringManager.Reset();
                });
+            if (followTargetObjective != null && subObjectives.Contains(followTargetObjective))
+            {
+                followTargetObjective.CloseEnough =
+                    WeaponComponent is RangedWeapon ? 3 :
+                    WeaponComponent is MeleeWeapon mw ? ConvertUnits.ToSimUnits(mw.Range) :
+                    WeaponComponent is RepairTool rt ? ConvertUnits.ToSimUnits(rt.Range) : 0.5f;
+            }
        }

-        private bool Reload(float deltaTime)
+        /// <summary>
+        /// Seeks for more ammunition. Creates a new subobjective.
+        /// </summary>
+        private void SeekAmmunition(string[] ammunitionIdentifiers)
        {
-            if (WeaponComponent != null && WeaponComponent.requiredItems.ContainsKey(RelatedItem.RelationType.Contained))
-            {
-                var containedItems = Weapon.ContainedItems;
-                foreach (RelatedItem requiredItem in WeaponComponent.requiredItems[RelatedItem.RelationType.Contained])
+            retreatTarget = null;
+            RemoveSubObjective(ref retreatObjective);
+            RemoveSubObjective(ref followTargetObjective);
+            TryAddSubObjective(ref seekAmmunition,
+                constructor: () => new AIObjectiveContainItem(character, ammunitionIdentifiers, Weapon.GetComponent<ItemContainer>(), objectiveManager)
                {
-                    Item containedItem = containedItems.FirstOrDefault(it => it.Condition > 0.0f && requiredItem.MatchesItem(it));
-                    if (containedItem == null)
+                    targetItemCount = Weapon.GetComponent<ItemContainer>().Capacity,
+                    checkInventory = false
+                },
+                onAbandon: () =>
+                {
+                    Weapon = null;
+                    Mode = CombatMode.Retreat;
+                    SteeringManager.Reset();
+                });
+        }
+        
+        /// <summary>
+        /// Reloads the ammunition found in the inventory.
+        /// If seekAmmo is true and the condition is met or not provided, tries to get find the ammo elsewhere.
+        /// </summary>
+        private bool Reload(bool seekAmmo, Func<bool> condition = null)
+        {
+            if (WeaponComponent == null) { return false; }
+            if (!WeaponComponent.requiredItems.ContainsKey(RelatedItem.RelationType.Contained)) { return false; }
+            var containedItems = Weapon.ContainedItems;
+            RelatedItem item = null;
+            Item ammunition = null;
+            string[] ammunitionIdentifiers = null;
+            foreach (RelatedItem requiredItem in WeaponComponent.requiredItems[RelatedItem.RelationType.Contained])
+            {
+                ammunition = containedItems.FirstOrDefault(it => it.Condition > 0.0f && requiredItem.MatchesItem(it));
+                if (ammunition != null)
+                {
+                    // Ammunition still remaining
+                    return true;
+                }
+                item = requiredItem;
+                ammunitionIdentifiers = requiredItem.Identifiers;
+            }
+            // No ammo
+            if (ammunition == null)
+            {
+                var container = Weapon.GetComponent<ItemContainer>();
+                // Try reload ammunition in inventory
+                foreach (string identifier in ammunitionIdentifiers)
+                {
+                    foreach (var i in character.Inventory.Items)
                    {
-                        TryAddSubObjective(ref reloadWeaponObjective, 
-                            constructor: () => new AIObjectiveContainItem(character, requiredItem.Identifiers, Weapon.GetComponent<ItemContainer>(), objectiveManager),
-                            onAbandon: () => 
+                        if (i == null) { continue; }
+                        if (i.Prefab.Identifier == identifier || i.HasTag(identifier))
+                        {
+                            if (i.Condition > 0)
                            {
-                                SteeringManager.Reset();
-                                Mode = CombatMode.Retreat;
-                            });
+                                container.Inventory.TryPutItem(ammunition, null);
+                            }
+                        }
                    }
                }
            }
-            return reloadWeaponObjective == null || reloadWeaponObjective.IsCompleted();
+            if (WeaponComponent.HasRequiredContainedItems(false))
+            {
+                return true;
+            }
+            else if (ammunition == null)
+            {
+                if (seekAmmo && ammunitionIdentifiers != null && (condition == null || condition()))
+                {
+                    SeekAmmunition(ammunitionIdentifiers);
+                }
+            }
+            return false;
        }

-        private IEnumerable<FarseerPhysics.Dynamics.Body> myBodies;
        private void Attack(float deltaTime)
        {
            float squaredDistance = Vector2.DistanceSquared(character.Position, Enemy.Position);
@@ -371,6 +457,16 @@ namespace Barotrauma
                    character.SetInput(InputType.Aim, false, true);
                }
            }
+            bool isFacing = character.AnimController.Dir > 0 && Enemy.WorldPosition.X > character.WorldPosition.X || character.AnimController.Dir < 0 && Enemy.WorldPosition.X < character.WorldPosition.X;
+            if (!isFacing)
+            {
+                aimTimer = Rand.Range(1f, 1.5f);
+            }
+            if (aimTimer > 0)
+            {
+                aimTimer -= deltaTime;
+                return;
+            }
            if (WeaponComponent is MeleeWeapon meleeWeapon)
            {
                if (squaredDistance <= meleeWeapon.Range * meleeWeapon.Range)
@@ -385,14 +481,14 @@ namespace Barotrauma
                {
                    if (squaredDistance > repairTool.Range * repairTool.Range) { return; }
                }
-                if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - character.Position) < MathHelper.PiOver4)
+                if (VectorExtensions.Angle(VectorExtensions.Forward(Weapon.body.TransformedRotation), Enemy.Position - Weapon.Position) < MathHelper.PiOver4)
                {
                    if (myBodies == null)
                    {
                        myBodies = character.AnimController.Limbs.Select(l => l.body.FarseerBody);
                    }
                    var collisionCategories = Physics.CollisionCharacter | Physics.CollisionWall;
-                    var pickedBody = Submarine.PickBody(character.SimPosition, Enemy.SimPosition, myBodies, collisionCategories);
+                    var pickedBody = Submarine.PickBody(Weapon.SimPosition, Enemy.SimPosition, myBodies, collisionCategories);
                    if (pickedBody != null)
                    {
                        Character target = null;
@@ -404,10 +500,11 @@ namespace Barotrauma
                        {
                            target = limb.character;
                        }
-                        if (target != null && target == Enemy)
+                        if (target != null && (target == Enemy || !HumanAIController.IsFriendly(target)))
                        {
                            character.SetInput(InputType.Shoot, false, true);
                            Weapon.Use(deltaTime, character);
+                            aimTimer = Rand.Range(0.25f, 0.5f);
                        }
                    }
                }