Build 1.1.4.0

2023-03-31 18:40:44 +03:00
parent efba17e0ff
commit 9470edead3
483 changed files with 17487 additions and 8548 deletions
@@ -19,15 +19,9 @@ namespace Barotrauma.Abilities

            foreach (XElement subElement in conditionElement.Elements())
            {
-                if (subElement.Name.ToString().Equals("conditional", StringComparison.OrdinalIgnoreCase))
+                if (subElement.NameAsIdentifier() == "conditional")
                {
-                    foreach (XAttribute attribute in subElement.Attributes())
-                    {
-                        if (PropertyConditional.IsValid(attribute))
-                        {
-                            conditionals.Add(new PropertyConditional(attribute));
-                        }
-                    }
+                    conditionals.AddRange(PropertyConditional.FromXElement(subElement));
                }
            }

@@ -14,45 +14,51 @@ namespace Barotrauma.Abilities
        {
            string[] missionTypeStrings = conditionElement.GetAttributeStringArray("missiontype", new []{ "None" })!;
            HashSet<MissionType> missionTypes = new HashSet<MissionType>();
+            isAffiliated = conditionElement.GetAttributeBool("isaffiliated", false);
+
            foreach (string missionTypeString in missionTypeStrings)
            {
                if (!Enum.TryParse(missionTypeString, out MissionType parsedMission) || parsedMission is MissionType.None)
                {
-                    DebugConsole.ThrowError($"Error in AbilityConditionMission \"{characterTalent.DebugIdentifier}\" - \"{missionTypeString}\" is not a valid mission type.");
-                    return;
+                    if (!isAffiliated)
+                    {
+                        DebugConsole.ThrowError($"Error in AbilityConditionMission \"{characterTalent.DebugIdentifier}\" - \"{missionTypeString}\" is not a valid mission type.");
+                    }
+                    continue;
                }

                missionTypes.Add(parsedMission);
            }

            missionType = missionTypes.ToImmutableHashSet();
-            isAffiliated = conditionElement.GetAttributeBool("isaffiliated", false);
        }

        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
        {
            if (abilityObject is IAbilityMission { Mission: { } mission })
            {
-                if (isAffiliated)
+                if (!isAffiliated) { return CheckMissionType(); }
+
+                if (GameMain.GameSession?.Campaign?.Factions is not { } factions) { return false; }
+
+                foreach (var (factionIdentifier, amount) in mission.ReputationRewards)
                {
-                    if (GameMain.GameSession?.Campaign?.Factions is not { } factions) { return false; }
-
-                    foreach (var (factionIdentifier, amount) in mission.ReputationRewards)
+                    if (amount <= 0) { continue; }
+                    if (GetMatchingFaction(factionIdentifier) is { } faction &&
+                        Faction.GetPlayerAffiliationStatus(faction) is FactionAffiliation.Positive)
                    {
-                        if (amount <= 0) { continue; }
-
-                        Faction faction = factions.FirstOrDefault(faction => factionIdentifier == faction.Prefab.Identifier);
-
-                        if (faction?.GetPlayerAffiliationStatus() is FactionAffiliation.Affiliated)
-                        {
-                            return true;
-                        }
+                        return CheckMissionType();
                    }
-
-                    return false;
                }

-                return missionType.Contains(mission.Prefab.Type);
+                return false;
+
+                Faction GetMatchingFaction(Identifier factionIdentifier) =>
+                    factionIdentifier == "location"
+                        ? mission.OriginLocation?.Faction
+                        : factions.FirstOrDefault(f => factionIdentifier == f.Prefab.Identifier);
+
+                bool CheckMissionType() => missionType.IsEmpty || missionType.Contains(mission.Prefab.Type);
            }

            LogAbilityConditionError(abilityObject, typeof(IAbilityMission));
@@ -23,7 +23,6 @@
        protected override bool MatchesConditionSpecific()
        {
            Identifier identifier = CharacterAbilityGivePermanentStat.HandlePlaceholders(placeholder, statIdentifier);
-
            return character.Info.GetSavedStatValue(statType, identifier) >= min;
        }
    }
@@ -4,6 +4,7 @@ using System;
 using Barotrauma.Extensions;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;

 namespace Barotrauma.Abilities
 {
@@ -29,11 +30,33 @@ namespace Barotrauma.Abilities

            if (!TalentTree.JobTalentTrees.TryGet(apprentice.Identifier, out TalentTree? talentTree)) { return; }

+            ImmutableHashSet<Character> characters = GameSession.GetSessionCrewCharacters(CharacterType.Both);
+
            HashSet<ImmutableHashSet<Identifier>> talentsTrees = new HashSet<ImmutableHashSet<Identifier>>();
            foreach (TalentSubTree subTree in talentTree.TalentSubTrees)
            {
                if (subTree.Type != TalentTreeType.Specialization) { continue; }
-                talentsTrees.Add(subTree.AllTalentIdentifiers);
+
+                HashSet<Identifier> identifiers = new HashSet<Identifier>();
+                foreach (TalentOption option in subTree.TalentOptionStages)
+                {
+                    foreach (Identifier identifier in option.TalentIdentifiers)
+                    {
+                        if (IsShowCaseTalent(identifier, option) || TalentTree.IsTalentLocked(identifier, characters)) { continue; }
+
+                        identifiers.Add(identifier);
+                    }
+
+                    foreach (var (_, value) in option.ShowCaseTalents)
+                    {
+                        var ids = value.Where(i => !TalentTree.IsTalentLocked(i, characters)).ToImmutableHashSet();
+                        if (ids.Count is 0) { continue; }
+
+                        identifiers.Add(value.GetRandomUnsynced());
+                    }
+                }
+
+                talentsTrees.Add(identifiers.ToImmutableHashSet());
            }

            ImmutableHashSet<Identifier> selectedTalentTree = talentsTrees.GetRandomUnsynced();
@@ -44,6 +67,16 @@ namespace Barotrauma.Abilities

                Character.GiveTalent(identifier);
            }
+
+            static bool IsShowCaseTalent(Identifier identifier, TalentOption option)
+            {
+                foreach (var (_, value) in option.ShowCaseTalents)
+                {
+                    if (value.Contains(identifier)) { return true; }
+                }
+
+                return false;
+            }
        }

        protected override void ApplyEffect(AbilityObject abilityObject)
@@ -131,6 +131,8 @@ namespace Barotrauma
            if (character.Info.GetTotalTalentPoints() - selectedTalents.Count <= 0) { return false; }
            if (!JobTalentTrees.TryGet(character.Info.Job.Prefab.Identifier, out TalentTree talentTree)) { return false; }

+            if (IsTalentLocked(talentIdentifier)) { return false; }
+
            foreach (var subTree in talentTree!.TalentSubTrees)
            {
                if (subTree.AllTalentIdentifiers.Contains(talentIdentifier) && subTree.HasMaxTalents(selectedTalents)) { return false; }
@@ -152,6 +154,18 @@ namespace Barotrauma
            return false;
        }

+        public static bool IsTalentLocked(Identifier talentIdentifier, ImmutableHashSet<Character> characterList = null)
+        {
+            characterList ??= GameSession.GetSessionCrewCharacters(CharacterType.Both);
+
+            foreach (Character c in characterList)
+            {
+                if (c.Info.GetSavedStatValue(StatTypes.LockedTalents, talentIdentifier) >= 1) { return true; }
+            }
+
+            return false;
+        }
+
        public static List<Identifier> CheckTalentSelection(Character controlledCharacter, IEnumerable<Identifier> selectedTalents)
        {
            List<Identifier> viableTalents = new List<Identifier>();