Unstable 0.16.0.0

2022-01-14 01:28:24 +09:00
parent d9baeaa2e1
commit 7d6421a548
237 changed files with 6430 additions and 2205 deletions
@@ -1,5 +1,6 @@
 using Barotrauma.Items.Components;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;

@@ -7,15 +8,19 @@ namespace Barotrauma.Abilities
 {
    class AbilityConditionAttackData : AbilityConditionData
    {
+        [Flags]
        private enum WeaponType
        {
            Any = 0, 
            Melee = 1, 
            Ranged = 2,
-            HandheldRanged = 3,
-            Turret = 4
+            HandheldRanged = 4,
+            Turret = 8,
+            NoWeapon = 16
        };

+        private static readonly List<WeaponType> WeaponTypeValues = Enum.GetValues(typeof(WeaponType)).Cast<WeaponType>().ToList();
+
        private readonly string itemIdentifier;
        private readonly string[] tags;
        private readonly WeaponType weapontype;
@@ -65,27 +70,39 @@ namespace Barotrauma.Abilities

                if (weapontype != WeaponType.Any)
                {
-                    switch (weapontype)
+                    foreach (WeaponType wt in WeaponTypeValues)
                    {
-                        // it is possible that an item that has both a melee and a projectile component will return true
-                        // even when not used as a melee/ranged weapon respectively
-                        // attackdata should contain data regarding whether the attack is melee or not
-                        case WeaponType.Melee:
-                            return item?.GetComponent<MeleeWeapon>() != null;
-                        case WeaponType.Ranged:
-                            return item?.GetComponent<Projectile>() != null;
-                        case WeaponType.HandheldRanged:
-                            {
-                                var projectile = item?.GetComponent<Projectile>();
-                                return projectile?.Launcher?.GetComponent<Holdable>() != null;
-                            }
-                        case WeaponType.Turret:
-                            {
-                                var projectile = item?.GetComponent<Projectile>();
-                                return projectile?.Launcher?.GetComponent<Turret>() != null;
-                            }
+                        if (wt == WeaponType.Any || !weapontype.HasFlag(wt)) { continue; }
+                        switch (wt)
+                        {
+                            // it is possible that an item that has both a melee and a projectile component will return true
+                            // even when not used as a melee/ranged weapon respectively
+                            // attackdata should contain data regarding whether the attack is melee or not
+                            case WeaponType.Melee:
+                                if (item?.GetComponent<MeleeWeapon>() != null) { return true; }
+                                break;
+                            case WeaponType.Ranged:
+                                if (item?.GetComponent<Projectile>() != null) { return true; }
+                                break;
+                            case WeaponType.HandheldRanged:
+                                {
+                                    var projectile = item?.GetComponent<Projectile>();
+                                    if (projectile?.Launcher?.GetComponent<Holdable>() != null) { return true; }
+                                }
+                                break;
+                            case WeaponType.Turret:
+                                {
+                                    var projectile = item?.GetComponent<Projectile>();
+                                    if (projectile?.Launcher?.GetComponent<Turret>() != null) { return true; }
+                                }
+                                break;
+                            case WeaponType.NoWeapon:
+                                if (item == null) { return true; }
+                                break;
+                        }
                    }
-                }
+                    return false;
+                }                

                return true;
            }
@@ -0,0 +1,38 @@
+using System.Xml.Linq;
+
+namespace Barotrauma.Abilities
+{
+    class AbilityConditionItemInSubmarine : AbilityConditionData
+    {
+        private readonly SubmarineType? submarineType;
+
+        public AbilityConditionItemInSubmarine(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) 
+        { 
+            if (conditionElement.Attribute("submarinetype") != null)
+            {
+                submarineType = conditionElement.GetAttributeEnum<SubmarineType>("submarinetype", SubmarineType.Player);
+            }
+        }
+
+        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
+        {
+            if ((abilityObject as IAbilityItem)?.Item is Item item)
+            {
+                if (item.Submarine == null) { return false; }
+                if (submarineType.HasValue)
+                {
+                    return item.Submarine.Info?.Type == submarineType.Value;
+                }
+                else
+                {
+                    return true;
+                }
+            }
+            else
+            {
+                LogAbilityConditionError(abilityObject, typeof(IAbilityItem));
+                return false;
+            }
+        }
+    }
+}
@@ -1,23 +0,0 @@
-using System.Xml.Linq;
-
-namespace Barotrauma.Abilities
-{
-    class AbilityConditionItemOutsideSubmarine : AbilityConditionData
-    {
-
-        public AbilityConditionItemOutsideSubmarine(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }
-
-        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
-        {
-            if ((abilityObject as IAbilityItem)?.Item is Item item)
-            {
-                return item.Submarine == null || item.Submarine.TeamID != character.Info.TeamID;
-            }
-            else
-            {
-                LogAbilityConditionError(abilityObject, typeof(IAbilityItem));
-                return false;
-            }
-        }
-    }
-}
@@ -1,23 +0,0 @@
-using System.Xml.Linq;
-
-namespace Barotrauma.Abilities
-{
-    class AbilityConditionItemWreck : AbilityConditionData
-    {
-
-        public AbilityConditionItemWreck(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }
-
-        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
-        {
-            if ((abilityObject as IAbilityItem)?.Item is Item item)
-            {
-                return item.Submarine?.Info?.IsWreck ?? false;
-            }
-            else
-            {
-                LogAbilityConditionError(abilityObject, typeof(IAbilityItem));
-                return false;
-            }
-        }
-    }
-}
@@ -18,13 +18,13 @@ namespace Barotrauma.Abilities

        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
        {
-            if ((abilityObject as IAbilityString)?.String is string skillIdentifier)
+            if ((abilityObject as IAbilitySkillIdentifier)?.SkillIdentifier is string skillIdentifier)
            {
                return MatchesConditionSpecific(skillIdentifier);
            }
            else
            {
-                LogAbilityConditionError(abilityObject, typeof(IAbilityString));
+                LogAbilityConditionError(abilityObject, typeof(IAbilitySkillIdentifier));
                return false;
            }
        }
@@ -30,9 +30,9 @@
        public Character Character { get; set; }
    }

-    interface IAbilityString
+    interface IAbilitySkillIdentifier
    {
-        public string String { get; set; }
+        public string SkillIdentifier { get; set; }
    }

    interface IAbilityAffliction
@@ -16,173 +16,4 @@ namespace Barotrauma.Abilities
        public Character Character { get; set; }
    }

-    class AbilityItem : AbilityObject, IAbilityItem
-    {
-        public AbilityItem(Item item)
-        {
-            Item = item;
-        }
-        public Item Item { get; set; }
-    }
-
-    class AbilityValue : AbilityObject, IAbilityValue
-    {
-        public AbilityValue(float value)
-        {
-            Value = value;
-        }
-        public float Value { get; set; }
-    }
-
-    class AbilityAffliction : AbilityObject, IAbilityAffliction
-    {
-        public AbilityAffliction(Affliction affliction)
-        {
-            Affliction = affliction;
-        }
-        public Affliction Affliction { get; set; }
-    }
-
-    class AbilityAfflictionCharacter : AbilityObject, IAbilityAffliction, IAbilityCharacter
-    {
-        public AbilityAfflictionCharacter(Affliction affliction, Character character)
-        {
-            Affliction = affliction;
-            Character = character;
-        }
-        public Character Character { get; set; }
-        public Affliction Affliction { get; set; }
-    }
-
-    class AbilityValueItem : AbilityObject, IAbilityValue, IAbilityItemPrefab
-    {
-        public AbilityValueItem(float value, ItemPrefab itemPrefab)
-        {
-            Value = value;
-            ItemPrefab = itemPrefab;
-        }
-        public float Value { get; set; }
-        public ItemPrefab ItemPrefab { get; set; }
-    }
-
-    class AbilityItemPrefabItem : AbilityObject, IAbilityItem, IAbilityItemPrefab
-    {
-        public AbilityItemPrefabItem(Item item, ItemPrefab itemPrefab)
-        {
-            Item = item;
-            ItemPrefab = itemPrefab;
-        }
-        public Item Item { get; set; }
-        public ItemPrefab ItemPrefab { get; set; }
-    }
-
-    class AbilityValueString : AbilityObject, IAbilityValue, IAbilityString
-    {
-        public AbilityValueString(float value, string abilityString)
-        {
-            Value = value;
-            String = abilityString;
-        }
-        public float Value { get; set; }
-        public string String { get; set; }
-    }
-
-    class AbilityStringCharacter : AbilityObject, IAbilityCharacter, IAbilityString
-    {
-        public AbilityStringCharacter(string abilityString, Character character)
-        {
-            String = abilityString;
-            Character = character;
-        }
-        public Character Character { get; set; }
-        public string String { get; set; }
-    }
-
-    class AbilityValueAffliction : AbilityObject, IAbilityValue, IAbilityAffliction
-    {
-        public AbilityValueAffliction(float value, Affliction affliction)
-        {
-            Value = value;
-            Affliction = affliction;
-        }
-        public float Value { get; set; }
-        public Affliction Affliction { get; set; }
-    }
-
-    class AbilityValueMission : AbilityObject, IAbilityValue, IAbilityMission
-    {
-        public AbilityValueMission(float value, Mission mission)
-        {
-            Value = value;
-            Mission = mission;
-        }
-        public float Value { get; set; }
-        public Mission Mission { get; set; }
-    }
-
-    class AbilityLocation : AbilityObject, IAbilityLocation
-    {
-        public AbilityLocation(Location location)
-        {
-            Location = location;
-        }
-
-        public Location Location { get; set; }
-    }
-
-    // this is an exception class that should only be passed in this form, so classes that use it should cast into it directly
-    class AbilityAttackData : AbilityObject, IAbilityCharacter
-    {
-        public float DamageMultiplier { get; set; } = 1f;
-        public float AddedPenetration { get; set; } = 0f;
-        public List<Affliction> Afflictions { get; set; }
-        public bool ShouldImplode { get; set; } = false;
-        public Attack SourceAttack { get; }
-        public Character Character { get; set; }
-        public Character Attacker { get; set; }
-
-        public AbilityAttackData(Attack sourceAttack, Character character)
-        {
-            SourceAttack = sourceAttack;
-            Character = character;
-        }
-    }
-
-    class AbilityApplyTreatment : AbilityObject, IAbilityCharacter, IAbilityItem
-    {
-        public Character Character { get; set; }
-
-        public Character User { get; set; }
-
-        public Item Item { get; set; }
-
-        public AbilityApplyTreatment(Character user, Character target, Item item)
-        {
-            Character = target;
-            User = user;
-            Item = item;
-        }
-    }
-
-    class AbilityAttackResult : AbilityObject, IAbilityAttackResult
-    {
-        public AttackResult AttackResult { get; set; }
-
-        public AbilityAttackResult(AttackResult attackResult)
-        {
-            AttackResult = attackResult;
-        }
-    }
-
-    class AbilityCharacterSubmarine : AbilityObject, IAbilityCharacter, IAbilitySubmarine
-    {
-        public AbilityCharacterSubmarine(Character character, Submarine submarine)
-        {
-            Character = character;
-            Submarine = submarine;
-        }
-        public Character Character { get; set; }
-        public Submarine Submarine { get; set; }
-    }
-
 }
@@ -87,7 +87,7 @@ namespace Barotrauma.Abilities
            DebugConsole.AddWarning($"Ability {this} used improperly! This ability does not take a parameter for ApplyEffect in talent {CharacterTalent.DebugIdentifier}");
        }

-        protected void LogabilityObjectMismatch()
+        protected void LogAbilityObjectMismatch()
        {
            DebugConsole.ThrowError($"Incompatible ability! Ability {this} is incompatitible with this type of ability effect type in talent {CharacterTalent.DebugIdentifier}");
        }
@@ -23,7 +23,7 @@ namespace Barotrauma.Abilities
            }
            else
            {
-                LogabilityObjectMismatch();
+                LogAbilityObjectMismatch();
            }
        }
    }
@@ -29,7 +29,7 @@ namespace Barotrauma.Abilities
            }
            else
            {
-                LogabilityObjectMismatch();
+                LogAbilityObjectMismatch();
            }
        }
    }
@@ -41,7 +41,7 @@ namespace Barotrauma.Abilities
            }
            else
            {
-                LogabilityObjectMismatch();
+                LogAbilityObjectMismatch();
            }
        }
    }
@@ -37,7 +37,7 @@ namespace Barotrauma.Abilities
            }
            else
            {
-                LogabilityObjectMismatch();
+                LogAbilityObjectMismatch();
            }
        }
    }
@@ -34,7 +34,7 @@ namespace Barotrauma.Abilities
            }
            else
            {
-                LogabilityObjectMismatch();
+                LogAbilityObjectMismatch();
            }
        }
    }
@@ -1,6 +1,4 @@
-using Microsoft.Xna.Framework;
-using System;
-using System.Xml.Linq;
+using System.Xml.Linq;

 namespace Barotrauma.Abilities
 {
@@ -18,7 +16,7 @@ namespace Barotrauma.Abilities
            if (abilityObject is AbilitySkillGain abilitySkillGain && abilitySkillGain.Character != Character)
            {
                if (ignoreAbilitySkillGain && abilitySkillGain.GainedFromAbility) { return; }
-                Character.Info?.IncreaseSkillLevel(abilitySkillGain.String, 1.0f, gainedFromAbility: true);
+                Character.Info?.IncreaseSkillLevel(abilitySkillGain.SkillIdentifier, 1.0f, gainedFromAbility: true);
            }
        }
    }
@@ -13,7 +13,7 @@ namespace Barotrauma.Abilities

        protected override void ApplyEffect(AbilityObject abilityObject)
        {
-            if ((abilityObject as IAbilityString)?.String is string skillIdentifier)
+            if ((abilityObject as IAbilitySkillIdentifier)?.SkillIdentifier is string skillIdentifier)
            {
                if (skillIdentifier != lastSkillIdentifier)
                {
@@ -9,7 +9,7 @@ namespace Barotrauma.Abilities
    class CharacterAbilityTandemFire : CharacterAbilityApplyStatusEffectsToNearestAlly
    {
        // this should just be its own class, misleading to inherit here
-        private string tag;
+        private readonly string tag;
        public CharacterAbilityTandemFire(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
        {
            tag = abilityElement.GetAttributeString("tag", "");
@@ -20,7 +20,7 @@ namespace Barotrauma.Abilities
            if (Character.SelectedConstruction == null || !Character.SelectedConstruction.HasTag(tag)) { return; }

            Character closestCharacter = null;
-            float closestDistance = float.MaxValue;
+            float closestDistance = squaredMaxDistance;

            foreach (Character crewCharacter in Character.GetFriendlyCrew(Character))
            {