Faction Test v1.0.1.0

2023-02-16 15:01:28 +02:00
parent caa5a2f762
commit 2c5a7923b0
309 changed files with 7502 additions and 4335 deletions
@@ -28,7 +28,6 @@ namespace Barotrauma.Abilities
                            conditionals.Add(new PropertyConditional(attribute));
                        }
                    }
-                    break;
                }
            }

@@ -37,19 +37,7 @@ namespace Barotrauma.Abilities

            if (itemPrefab != null)
            {
-                if (category != MapEntityCategory.None)
-                {
-                    if (!itemPrefab.Category.HasFlag(category)) { return false; }
-                }
-
-                if (identifiers.Any())
-                {
-                    if (!identifiers.Any(t => itemPrefab.Identifier == t))
-                    {
-                        return false;
-                    }
-                }
-                return !tags.Any() || tags.Any(t => itemPrefab.Tags.Any(p => t == p));
+                return MatchesItem(itemPrefab);
            }
            else
            {
@@ -57,5 +45,22 @@ namespace Barotrauma.Abilities
                return false;
            }
        }
+
+        public bool MatchesItem(ItemPrefab itemPrefab)
+        {
+            if (category != MapEntityCategory.None)
+            {
+                if (!itemPrefab.Category.HasFlag(category)) { return false; }
+            }
+
+            if (identifiers.Any())
+            {
+                if (!identifiers.Any(t => itemPrefab.Identifier == t))
+                {
+                    return false;
+                }
+            }
+            return !tags.Any() || tags.Any(t => itemPrefab.Tags.Any(p => t == p));
+        }
    }
 }
@@ -8,19 +8,19 @@ namespace Barotrauma.Abilities
    class AbilityConditionMission : AbilityConditionData
    {
        private readonly ImmutableHashSet<MissionType> missionType;
-        private readonly ImmutableHashSet<Identifier> factions;
+        private readonly bool isAffiliated;

        public AbilityConditionMission(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
        {
            string[] missionTypeStrings = conditionElement.GetAttributeStringArray("missiontype", new []{ "None" })!;
            HashSet<MissionType> missionTypes = new HashSet<MissionType>();
-            factions = conditionElement.GetAttributeIdentifierImmutableHashSet("faction", ImmutableHashSet<Identifier>.Empty);
+            isAffiliated = conditionElement.GetAttributeBool("isaffiliated", false);

            foreach (string missionTypeString in missionTypeStrings)
            {
                if (!Enum.TryParse(missionTypeString, out MissionType parsedMission) || parsedMission is MissionType.None)
                {
-                    if (factions.IsEmpty)
+                    if (!isAffiliated)
                    {
                        DebugConsole.ThrowError($"Error in AbilityConditionMission \"{characterTalent.DebugIdentifier}\" - \"{missionTypeString}\" is not a valid mission type.");
                    }
@@ -37,23 +37,28 @@ namespace Barotrauma.Abilities
        {
            if (abilityObject is IAbilityMission { Mission: { } mission })
            {
-                if (factions.Any())
-                {
-                    if (GameMain.GameSession?.Campaign?.Factions is not { } factions) { return false; }
+                if (!isAffiliated) { return CheckMissionType(); }

-                    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; }
-                        if (factions.FirstOrDefault(faction => factionIdentifier == faction.Prefab.Identifier) is Faction faction &&
-                            Faction.GetPlayerAffiliationStatus(faction) is FactionAffiliation.Positive)
-                        {
-                            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));
@@ -1,19 +1,35 @@
 #nullable enable

+using Barotrauma.Extensions;
 using Barotrauma.Items.Components;
+using System.Collections.Generic;
+using System.Linq;

 namespace Barotrauma.Abilities
 {
    internal sealed class CharacterAbilityRemoveRandomIngredient : CharacterAbility
    {
-        public CharacterAbilityRemoveRandomIngredient(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement) { }
+        private readonly AbilityConditionItem? condition;
+
+        public CharacterAbilityRemoveRandomIngredient(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement) 
+        {
+            var conditionElement = abilityElement.GetChildElement(nameof(AbilityConditionItem));
+            if (conditionElement != null)
+            {
+                condition = new AbilityConditionItem(CharacterTalent, conditionElement);
+            }
+        }

        protected override void ApplyEffect(AbilityObject abilityObject)
        {
            if (abilityObject is not Fabricator.AbilityFabricationItemIngredients { Items.Count: > 0 } ingredients) { return; }

-            int randomIndex = Rand.Int(ingredients.Items.Count, Rand.RandSync.Unsynced);
-            ingredients.Items.RemoveAt(randomIndex);
+            List<Item> applicableIngredients = condition == null ?
+                ingredients.Items.ToList() :
+                ingredients.Items.Where(it => condition.MatchesItem(it.Prefab)).ToList();
+            if (applicableIngredients.None()) { return; }
+
+            ingredients.Items.Remove(applicableIngredients.GetRandom(Rand.RandSync.Unsynced));
        }
    }
 }