Unstable 0.1500.5.0 (almost forgor edition 💀)

2021-10-01 23:56:14 +09:00
parent 3043a9a7bc
commit 08bdfc6cea
150 changed files with 5669 additions and 4403 deletions
@@ -23,7 +23,7 @@ namespace Barotrauma.Abilities

                if (afflictions.Any())
                {
-                    if (!afflictions.Any(a => attackResult.Afflictions.Select(c => c.Identifier).Contains(a))) { return false; }
+                    if (attackResult.Afflictions == null || !afflictions.Any(a => attackResult.Afflictions.Select(c => c.Identifier).Contains(a))) { return false; }
                }

                return true;
@@ -2,10 +2,10 @@

 namespace Barotrauma.Abilities
 {
-    class AbilityConditionScavenger : AbilityConditionData
+    class AbilityConditionItemOutsideSubmarine : AbilityConditionData
    {

-        public AbilityConditionScavenger(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }
+        public AbilityConditionItemOutsideSubmarine(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }

        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
        {
@@ -2,10 +2,10 @@

 namespace Barotrauma.Abilities
 {
-    class AbilityConditionScrounger : AbilityConditionData
+    class AbilityConditionItemWreck : AbilityConditionData
    {

-        public AbilityConditionScrounger(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }
+        public AbilityConditionItemWreck(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement) { }

        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
        {
@@ -5,19 +5,25 @@ namespace Barotrauma.Abilities
 {
    class AbilityConditionHasPermanentStat : AbilityConditionDataless
    {
+        private readonly string statIdentifier;
        private readonly StatTypes statType;
        private readonly float min;

        public AbilityConditionHasPermanentStat(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement)
        {
-            statType = CharacterAbilityGroup.ParseStatType(conditionElement.GetAttributeString("stattype", ""), characterTalent.DebugIdentifier);
+            statIdentifier = conditionElement.GetAttributeString("statidentifier", string.Empty);
+            if (string.IsNullOrEmpty(statIdentifier))
+            {
+                DebugConsole.ThrowError($"No stat identifier defined for {this} in talent {characterTalent.DebugIdentifier}!");
+            }
+            string statTypeName = conditionElement.GetAttributeString("stattype", string.Empty);
+            statType = string.IsNullOrEmpty(statTypeName) ? StatTypes.None : CharacterAbilityGroup.ParseStatType(statTypeName, characterTalent.DebugIdentifier);
            min = conditionElement.GetAttributeFloat("min", 0f);
        }

        protected override bool MatchesConditionSpecific()
        {
-            // should consider decoupling this from stat values entirely
-            return character.Info.GetSavedStatValue(statType) >= min;
+            return character.Info.GetSavedStatValue(statType, statIdentifier) >= min;
        }
    }
 }
@@ -0,0 +1,24 @@
+using Barotrauma.Items.Components;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Abilities
+{
+    class AbilityConditionHasSkill : AbilityConditionDataless
+    {
+        private readonly string skillIdentifier;
+        private readonly float minValue;
+
+        public AbilityConditionHasSkill(CharacterTalent characterTalent, XElement conditionElement) : base(characterTalent, conditionElement)
+        {
+            skillIdentifier = conditionElement.GetAttributeString("skillidentifier", string.Empty);
+            minValue = conditionElement.GetAttributeFloat("minvalue", 0f);
+        }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            return character.GetSkillLevel(skillIdentifier) >= minValue;
+        }
+    }
+}
@@ -2,7 +2,7 @@

 namespace Barotrauma.Abilities
 {
-    class AbilityObject
+    abstract class AbilityObject
    {
        // kept as blank for now, as we are using a composition and only using this object to enforce parameter types
    }
@@ -160,6 +160,22 @@ namespace Barotrauma.Abilities
        }
    }

+    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; }
@@ -62,7 +62,7 @@ namespace Barotrauma.Abilities

        protected virtual void VerifyState(bool conditionsMatched, float timeSinceLastUpdate)
        {
-            DebugConsole.ThrowError($"Ability {this} does not have an implementation for VerifyState! This ability does not work in interval ability groups.");
+            DebugConsole.ThrowError($"Error in talent {CharacterTalent.DebugIdentifier}: Ability {this} does not have an implementation for VerifyState! This ability does not work in interval ability groups.");
        }

        public void ApplyAbilityEffect(AbilityObject abilityObject)
@@ -128,14 +128,5 @@ namespace Barotrauma.Abilities
            DebugConsole.AddWarning("Instantiated " + characterAbility + " for talent " + characterAbilityGroup.CharacterTalent.DebugIdentifier);
            return characterAbility;
        }
-        public static AbilityFlags ParseFlagType(string flagTypeString, string debugIdentifier)
-        {
-            AbilityFlags flagType = AbilityFlags.None;
-            if (!Enum.TryParse(flagTypeString, true, out flagType))
-            {
-                DebugConsole.ThrowError("Invalid flag type type \"" + flagTypeString + "\" in CharacterTalent (" + debugIdentifier + ")");
-            }
-            return flagType;
-        }
    }
 }
@@ -0,0 +1,44 @@
+using System.Xml.Linq;
+
+namespace Barotrauma.Abilities
+{
+    class CharacterAbilityGiveAffliction : CharacterAbility
+    {
+        private readonly string afflictionId;
+        private readonly float strength;
+        private readonly string multiplyStrengthBySkill;
+        private readonly bool setValue;
+
+        public CharacterAbilityGiveAffliction(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            afflictionId = abilityElement.GetAttributeString("afflictionid", abilityElement.GetAttributeString("affliction", string.Empty));
+            strength = abilityElement.GetAttributeFloat("strength", 0f);
+            multiplyStrengthBySkill = abilityElement.GetAttributeString("multiplystrengthbyskill", string.Empty);
+            setValue = abilityElement.GetAttributeBool("setvalue", false);
+
+            if (string.IsNullOrEmpty(afflictionId))
+            {
+                DebugConsole.ThrowError("Error in CharacterAbilityGiveAffliction - affliction identifier not set.");
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            if (abilityObject is IAbilityCharacter character)
+            {
+                var afflictionPrefab = AfflictionPrefab.Prefabs.Find(a => a.Identifier.Equals(afflictionId, System.StringComparison.OrdinalIgnoreCase));
+                if (afflictionPrefab == null)
+                {
+                    DebugConsole.ThrowError($"Error in CharacterAbilityGiveAffliction - could not find an affliction with the identifier \"{afflictionId}\".");
+                    return;
+                }
+                float strength = this.strength;
+                if (!string.IsNullOrEmpty(multiplyStrengthBySkill))
+                {
+                    strength *= Character.GetSkillLevel(multiplyStrengthBySkill);
+                }
+                character.Character.CharacterHealth.ApplyAffliction(null, afflictionPrefab.Instantiate(strength), allowStacking: !setValue);
+            }
+        }
+    }
+}
@@ -4,12 +4,12 @@ namespace Barotrauma.Abilities
 {
    class CharacterAbilityGiveFlag : CharacterAbility
    {
-        private AbilityFlags abilityFlag;
+        private readonly AbilityFlags abilityFlag;

        // this and resistance giving should probably be moved directly to charactertalent attributes, as they don't need to interact with either ability group types
        public CharacterAbilityGiveFlag(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
        {
-            abilityFlag = ParseFlagType(abilityElement.GetAttributeString("flagtype", ""), CharacterTalent.DebugIdentifier);
+            abilityFlag = CharacterAbilityGroup.ParseFlagType(abilityElement.GetAttributeString("flagtype", ""), CharacterTalent.DebugIdentifier);
        }

        public override void InitializeAbility(bool addingFirstTime)
@@ -7,20 +7,20 @@ namespace Barotrauma.Abilities
        public override bool AppliesEffectOnIntervalUpdate => true;

        private readonly int amount;
-        private readonly StatTypes scalingStatType;
+        private readonly string scalingStatIdentifier;

        public CharacterAbilityGiveMoney(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
        {
            amount = abilityElement.GetAttributeInt("amount", 0);
-            scalingStatType = CharacterAbilityGroup.ParseStatType(abilityElement.GetAttributeString("scalingstattype", "None"), CharacterTalent.DebugIdentifier);
+            scalingStatIdentifier = abilityElement.GetAttributeString("scalingstatidentifier", string.Empty);
        }

        private void ApplyEffectSpecific(Character targetCharacter)
        {
            float multiplier = 1f;
-            if (scalingStatType != StatTypes.None)
+            if (!string.IsNullOrEmpty(scalingStatIdentifier))
            {
-                multiplier = 0 + Character.Info.GetSavedStatValue(scalingStatType);
+                multiplier = 0 + Character.Info.GetSavedStatValue(StatTypes.None, scalingStatIdentifier);
            }

            targetCharacter.GiveMoney((int)(multiplier * amount));
@@ -11,7 +11,6 @@ namespace Barotrauma.Abilities
        private readonly float maxValue;
        private readonly bool targetAllies;
        private readonly bool removeOnDeath;
-        private readonly bool removeAfterRound;
        private readonly bool giveOnAddingFirstTime;
        private readonly bool setValue;

@@ -22,12 +21,12 @@ namespace Barotrauma.Abilities
        public CharacterAbilityGivePermanentStat(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
        {
            statIdentifier = abilityElement.GetAttributeString("statidentifier", "").ToLowerInvariant();
-            statType = CharacterAbilityGroup.ParseStatType(abilityElement.GetAttributeString("stattype", ""), CharacterTalent.DebugIdentifier);
+            string statTypeName = abilityElement.GetAttributeString("stattype", string.Empty);
+            statType = string.IsNullOrEmpty(statTypeName) ? StatTypes.None : CharacterAbilityGroup.ParseStatType(statTypeName, CharacterTalent.DebugIdentifier);
            value = abilityElement.GetAttributeFloat("value", 0f);
            maxValue = abilityElement.GetAttributeFloat("maxvalue", float.MaxValue);
            targetAllies = abilityElement.GetAttributeBool("targetallies", false);
            removeOnDeath = abilityElement.GetAttributeBool("removeondeath", true);
-            removeAfterRound = abilityElement.GetAttributeBool("removeafterround", false);
            giveOnAddingFirstTime = abilityElement.GetAttributeBool("giveonaddingfirsttime", characterAbilityGroup.AbilityEffectType == AbilityEffectType.None);
            setValue = abilityElement.GetAttributeBool("setvalue", false);
        }
@@ -54,11 +53,11 @@ namespace Barotrauma.Abilities
        {
            if (targetAllies)
            {
-                Character.GetFriendlyCrew(Character).ForEach(c => c?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, removeAfterRound, maxValue, setValue));
+                Character.GetFriendlyCrew(Character).ForEach(c => c?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, maxValue: maxValue, setValue: setValue));
            }
            else
            {
-                Character?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, removeAfterRound, maxValue, setValue);
+                Character?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, maxValue: maxValue, setValue: setValue);
            }
        }
    }
@@ -5,13 +5,13 @@ namespace Barotrauma.Abilities
 {
    class CharacterAbilityModifyFlag : CharacterAbility
    {
-        private AbilityFlags abilityFlag;
+        private readonly AbilityFlags abilityFlag;

        private bool lastState;

        public CharacterAbilityModifyFlag(CharacterAbilityGroup characterAbilityGroup, XElement abilityElement) : base(characterAbilityGroup, abilityElement)
        {
-            abilityFlag = ParseFlagType(abilityElement.GetAttributeString("flagtype", ""), CharacterTalent.DebugIdentifier);
+            abilityFlag = CharacterAbilityGroup.ParseFlagType(abilityElement.GetAttributeString("flagtype", ""), CharacterTalent.DebugIdentifier);
        }

        protected override void VerifyState(bool conditionsMatched, float timeSinceLastUpdate)
@@ -208,5 +208,15 @@ namespace Barotrauma.Abilities

            return afflictions;
        }
+
+        public static AbilityFlags ParseFlagType(string flagTypeString, string debugIdentifier)
+        {
+            AbilityFlags flagType = AbilityFlags.None;
+            if (!Enum.TryParse(flagTypeString, true, out flagType))
+            {
+                DebugConsole.ThrowError("Invalid flag type type \"" + flagTypeString + "\" in CharacterTalent (" + debugIdentifier + ")");
+            }
+            return flagType;
+        }
    }
 }
@@ -30,7 +30,7 @@ namespace Barotrauma
        {
            ConfigElement = element;

-            string jobIdentifier = element.GetAttributeString("jobidentifier", "");
+            string jobIdentifier = element.GetAttributeString("jobidentifier", "").ToLowerInvariant();

            if (string.IsNullOrEmpty(jobIdentifier))
            {