PropertyConditional.cs

#nullable enable
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Globalization;
using System.Linq;
using System.Xml.Linq;
using Barotrauma.Items.Components;
 
namespace Barotrauma
{
    sealed class PropertyConditional
    {
        // TODO: Make this testable and add tests
 
        public enum ConditionType
        {
            PropertyValueOrAffliction,
 
            SkillRequirement,
 
            Name,
 
            SpeciesName,
 
            SpeciesGroup,
 
            HasTag,
 
            HasStatusTag,
 
            HasSpecifierTag,
 
            EntityType,
 
            LimbType,
 
            WorldHostility
        }
 
        public enum LogicalOperatorType
        {
            And,
            Or
        }
 
        public enum ComparisonOperatorType
        {
            None,
 
            Equals,
 
            NotEquals,
 
            LessThan,
 
            LessThanEquals,
 
            GreaterThan,
 
            GreaterThanEquals
        }
 
        public readonly ConditionType Type;
        public readonly ComparisonOperatorType ComparisonOperator;
        public readonly Identifier AttributeName;
        public readonly string AttributeValue;
        public readonly ImmutableArray<Identifier> AttributeValueAsTags;
        public readonly float? FloatValue;
 
        private readonly WorldHostilityOption cachedHostilityValue;
 
        public readonly string TargetItemComponent;
 
        public readonly bool TargetSelf;
 
        public readonly bool TargetContainer;
 
        public readonly bool TargetGrandParent;
 
        public readonly bool TargetContainedItem;
 
        public static IEnumerable<PropertyConditional> FromXElement(ContentXElement element, Predicate<XAttribute>? predicate = null)
        {
            var targetItemComponent = element.GetAttributeString(nameof(TargetItemComponent), "");
            var targetContainer = element.GetAttributeBool(nameof(TargetContainer), false);
            var targetSelf = element.GetAttributeBool(nameof(TargetSelf), false);
            var targetGrandParent = element.GetAttributeBool(nameof(TargetGrandParent), false);
            var targetContainedItem = element.GetAttributeBool(nameof(TargetContainedItem), false);
 
            ConditionType? overrideConditionType = null;
            if (element.GetAttributeBool(nameof(ConditionType.SkillRequirement), false))
            {
                overrideConditionType = ConditionType.SkillRequirement;
            }
 
            foreach (var attribute in element.Attributes())
            {
                if (!IsValid(attribute)) { continue; }
                if (predicate != null && !predicate(attribute)) { continue; }
 
                var (comparisonOperator, attributeValueString) = ExtractComparisonOperatorFromConditionString(attribute.Value);
                if (string.IsNullOrWhiteSpace(attributeValueString))
                {
                    DebugConsole.ThrowError($"Conditional attribute value is empty: {element}", contentPackage: element.ContentPackage);
                    continue;
                }
 
                var conditionType = overrideConditionType ??
                    (Enum.TryParse(attribute.Name.LocalName, ignoreCase: true, out ConditionType type)
                        ? type
                        : ConditionType.PropertyValueOrAffliction);
 
                yield return new PropertyConditional(
                    attributeName: attribute.NameAsIdentifier(),
                    comparisonOperator: comparisonOperator,
                    attributeValue: attributeValueString,
                    targetItemComponent: targetItemComponent,
                    targetSelf: targetSelf,
                    targetContainer: targetContainer,
                    targetGrandParent: targetGrandParent,
                    targetContainedItem: targetContainedItem,
                    conditionType: conditionType);
            }
        }
 
        private static bool IsValid(XAttribute attribute)
        {
            switch (attribute.Name.ToString().ToLowerInvariant())
            {
                case "targetitemcomponent":
                case "targetself":
                case "targetcontainer":
                case "targetgrandparent":
                case "targetcontaineditem":
                case "skillrequirement":
                case "targetslot":
                    return false;
                default:
                    return true;
            }
        }
 
        private PropertyConditional(
            Identifier attributeName,
            ComparisonOperatorType comparisonOperator,
            string attributeValue,
            string targetItemComponent,
            bool targetSelf,
            bool targetContainer,
            bool targetGrandParent,
            bool targetContainedItem,
            ConditionType conditionType)
        {
            AttributeName = attributeName;
 
            TargetItemComponent = targetItemComponent;
            TargetSelf = targetSelf;
            TargetContainer = targetContainer;
            TargetGrandParent = targetGrandParent;
            TargetContainedItem = targetContainedItem;
 
            Type = conditionType;
 
            ComparisonOperator = comparisonOperator;
            AttributeValue = attributeValue;
            AttributeValueAsTags = AttributeValue.Split(',')
                .Select(s => s.ToIdentifier())
                .ToImmutableArray();
            if (float.TryParse(AttributeValue, NumberStyles.Float, CultureInfo.InvariantCulture, out float value))
            {
                FloatValue = value;
            }
 
            if (Type == ConditionType.WorldHostility && Enum.TryParse(AttributeValue, ignoreCase: true, out WorldHostilityOption hostilityValue))
            {
                cachedHostilityValue = hostilityValue;
            }
        }
 
        public static (ComparisonOperatorType ComparisonOperator, string ConditionStr) ExtractComparisonOperatorFromConditionString(string str)
        {
            str ??= "";
 
            ComparisonOperatorType op = ComparisonOperatorType.Equals;
            string conditionStr = str;
            if (str.IndexOf(' ') is var i and >= 0)
            {
                op = GetComparisonOperatorType(str[..i]);
                if (op != ComparisonOperatorType.None) { conditionStr = str[(i + 1)..]; }
                else { op = ComparisonOperatorType.Equals; }
            }
            return (op, conditionStr);
        }
 
        public static ComparisonOperatorType GetComparisonOperatorType(string op)
        {
            //thanks xml for not letting me use < or > in attributes :(
            switch (op.ToLowerInvariant())
            {
                case "e":
                case "eq":
                case "equals":
                    return ComparisonOperatorType.Equals;
                case "ne":
                case "neq":
                case "notequals":
                case "!":
                case "!e":
                case "!eq":
                case "!equals":
                    return ComparisonOperatorType.NotEquals;
                case "gt":
                case "greaterthan":
                    return ComparisonOperatorType.GreaterThan;
                case "lt":
                case "lessthan":
                    return ComparisonOperatorType.LessThan;
                case "gte":
                case "gteq":
                case "greaterthanequals":
                    return ComparisonOperatorType.GreaterThanEquals;
                case "lte":
                case "lteq":
                case "lessthanequals":
                    return ComparisonOperatorType.LessThanEquals;
                default:
                    return ComparisonOperatorType.None;
            }
        }
 
        private bool ComparisonOperatorIsNotEquals => ComparisonOperator == ComparisonOperatorType.NotEquals;
 
        public bool Matches(ISerializableEntity? target)
        {
            return TargetContainedItem
                ? MatchesContained(target)
                : MatchesDirect(target);
        }
 
        private bool MatchesContained(ISerializableEntity? target)
        {
            var containedItems = target switch
            {
                Item item
                    => item.ContainedItems,
                ItemComponent ic
                    => ic.Item.ContainedItems,
                Character {Inventory: { } characterInventory}
                    => characterInventory.AllItems,
                _
                    => Enumerable.Empty<Item>()
            };
            foreach (var containedItem in containedItems)
            {
                if (MatchesDirect(containedItem)) { return true; }
            }
            return false;
        }
 
        private bool MatchesDirect(ISerializableEntity? target)
        {
            Character? targetChar = target as Character;
            if (target is Limb limb) { targetChar = limb.character; }
            switch (Type)
            {
                case ConditionType.PropertyValueOrAffliction:
                    // If an AfflictionPrefab with identifier AttributeName exists,
                    // check for an affliction affecting the target
                    if (AfflictionPrefab.Prefabs.ContainsKey(AttributeName))
                    {
                        if (targetChar is { CharacterHealth: { } health })
                        {
                            var affliction = health.GetAffliction(AttributeName);
                            float afflictionStrength = affliction?.Strength ?? 0f;
 
                            return NumberMatchesRequirement(afflictionStrength);
                        }
                    }
                    // Otherwise try checking for a property belonging to the target
                    else if (target?.SerializableProperties != null
                        && target.SerializableProperties.TryGetValue(AttributeName, out var property))
                    {
                        return PropertyMatchesRequirement(target, property);
                    }
                    else if (targetChar?.SerializableProperties != null
                        && targetChar.SerializableProperties.TryGetValue(AttributeName, out var characterProperty))
                    {
                        return PropertyMatchesRequirement(targetChar, characterProperty);
                    }
                    return ComparisonOperatorIsNotEquals;
                case ConditionType.SkillRequirement:
                    if (targetChar != null)
                    {
                        float skillLevel = targetChar.GetSkillLevel(AttributeName.ToIdentifier());
 
                        return NumberMatchesRequirement(skillLevel);
                    }
                    return ComparisonOperatorIsNotEquals;
                case ConditionType.HasTag:
                    return ItemMatchesTagCondition(target);
                case ConditionType.HasStatusTag:
                    if (target == null) { return ComparisonOperatorIsNotEquals; }
 
                    int numTagsFound = 0;
                    foreach (var tag in AttributeValueAsTags)
                    {
                        bool tagFound = false;
                        foreach (var durationEffect in StatusEffect.DurationList)
                        {
                            if (!durationEffect.Targets.Contains(target)) { continue; }
                            if (durationEffect.Parent.HasTag(tag))
                            {
                                tagFound = true;
                                break;
                            }
                        }
                        if (!tagFound)
                        {
                            foreach (var delayedEffect in DelayedEffect.DelayList)
                            {
                                if (!delayedEffect.Targets.Contains(target)) { continue; }
                                if (delayedEffect.Parent.HasTag(tag))
                                {
                                    tagFound = true;
                                    break;
                                }
                            }
                        }
                        if (tagFound)
                        {
                            numTagsFound++;
                        }
                    }
                    return ComparisonOperatorIsNotEquals
                        ? numTagsFound < AttributeValueAsTags.Length // true when some tag wasn't found
                        : numTagsFound >= AttributeValueAsTags.Length; // true when all the tags are found
                case ConditionType.WorldHostility:
                {
                    if (GameMain.GameSession?.Campaign is CampaignMode campaign)
                    {
                        return Compare(campaign.Settings.WorldHostility, cachedHostilityValue, ComparisonOperator);
                    }
                    return false;
                }
                default:
                    bool equals = CheckOnlyEquality(target);
                    return ComparisonOperatorIsNotEquals
                        ? !equals
                        : equals;
            }
        }
 
        private bool CheckOnlyEquality(ISerializableEntity? target)
        {
            switch (Type)
            {
                case ConditionType.Name:
                    if (target == null) { return false; }
 
                    return target.Name == AttributeValue;
                case ConditionType.HasSpecifierTag:
                {
                    if (target is not Character {Info: { } characterInfo})
                    {
                        return false;
                    }
 
                    return AttributeValueAsTags.All(characterInfo.Head.Preset.TagSet.Contains);
                }
                case ConditionType.SpeciesName:
                {
                    if (target is Character targetCharacter)
                    {
                        return targetCharacter.SpeciesName == AttributeValue;
                    }
                    else if (target is Limb targetLimb)
                    {
                        return targetLimb.character.SpeciesName == AttributeValue;
                    }
                    return false;                    
                }
                case ConditionType.SpeciesGroup:
                    {
                        if (target is Character targetCharacter)
                        {
                            return CharacterParams.CompareGroup(AttributeValue.ToIdentifier(), targetCharacter.Params.Group);
                        }
                        else if (target is Limb targetLimb)
                        {
                            return CharacterParams.CompareGroup(AttributeValue.ToIdentifier(), targetLimb.character.Params.Group);
                        }
                        return false;
                    }
                case ConditionType.EntityType:
                    return AttributeValue.ToLowerInvariant() switch
                    {
                        "character"
                            => target is Character,
                        "limb"
                            => target is Limb,
                        "item"
                            => target is Item,
                        "structure"
                            => target is Structure,
                        "null"
                            => target == null,
                        _
                            => false
                    };
                case ConditionType.LimbType:
                {
                    return target is Limb limb
                           && Enum.TryParse(AttributeValue, ignoreCase: true, out LimbType attributeLimbType)
                           && attributeLimbType == limb.type;
                }
            }
            return false;
        }
 
        private bool SufficientTagMatches(int matches)
        {
            return ComparisonOperatorIsNotEquals
                ? matches <= 0
                : matches >= AttributeValueAsTags.Length;
        }
 
        private bool ItemMatchesTagCondition(ISerializableEntity? target)
        {
            if (target is not Item item) { return ComparisonOperatorIsNotEquals; }
 
            int matches = 0;
            foreach (var tag in AttributeValueAsTags)
            {
                if (item.HasTag(tag)) { matches++; }
            }
            return SufficientTagMatches(matches);
        }
 
        public bool TargetTagMatchesTagCondition(Identifier targetTag)
        {
            if (targetTag.IsEmpty || Type != ConditionType.HasTag) { return false; }
 
            int matches = 0;
            foreach (var tag in AttributeValueAsTags)
            {
                if (targetTag == tag) { matches++; }
            }
            return SufficientTagMatches(matches);
        }
 
        private bool NumberMatchesRequirement(float testedValue)
        {
            if (!FloatValue.HasValue) { return ComparisonOperatorIsNotEquals; }
            float value = FloatValue.Value;
            return CompareFloat(testedValue, value, ComparisonOperator);
        }
 
        private bool PropertyMatchesRequirement(ISerializableEntity target, SerializableProperty property)
        {
            Type type = property.PropertyType;
 
            if (type == typeof(float) || type == typeof(int))
            {
                float floatValue = property.GetFloatValue(target);
                return NumberMatchesRequirement(floatValue);
            }
 
            switch (ComparisonOperator)
            {
                case ComparisonOperatorType.Equals:
                case ComparisonOperatorType.NotEquals:
                    bool equals;
                    if (type == typeof(bool))
                    {
                        bool attributeValueBool = AttributeValue.IsTrueString();
                        equals = property.GetBoolValue(target) == attributeValueBool;
                    }
                    else
                    {
                        var value = property.GetValue(target);
                        equals = AreValuesEquivalent(value, AttributeValue);
                    }
 
                    return ComparisonOperatorIsNotEquals
                        ? !equals
                        : equals;
                default:
                    DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" (" + type + ")! "
                        + "Make sure the type of the value set in the config files matches the type of the property.");
                    return false;
            }
 
            static bool AreValuesEquivalent(object? value, string desiredValue)
            {
                if (value == null)
                {
                    return desiredValue.Equals("null", StringComparison.OrdinalIgnoreCase);
                }
                else
                {
                    return (value.ToString() ?? "").Equals(desiredValue);
                }
            }
        }
 
        public static bool CompareFloat(float val1, float val2, ComparisonOperatorType op)
        {
            switch (op)
            {
                case ComparisonOperatorType.Equals:
                    return MathUtils.NearlyEqual(val1, val2);
                case ComparisonOperatorType.GreaterThan:
                    return val1 > val2;
                case ComparisonOperatorType.GreaterThanEquals:
                    return val1 >= val2;
                case ComparisonOperatorType.LessThan:
                    return val1 < val2;
                case ComparisonOperatorType.LessThanEquals:
                    return val1 <= val2;
                case ComparisonOperatorType.NotEquals:
                    return !MathUtils.NearlyEqual(val1, val2);
                default:
                    return false;
            }
        }
 
        public static bool Compare<T>(T leftValue, T rightValue, ComparisonOperatorType comparisonOperator) where T : IComparable
        {
            return comparisonOperator switch
            {
                ComparisonOperatorType.NotEquals => leftValue.CompareTo(rightValue) != 0,
                ComparisonOperatorType.GreaterThan => leftValue.CompareTo(rightValue) > 0,
                ComparisonOperatorType.LessThan => leftValue.CompareTo(rightValue) < 0,
                ComparisonOperatorType.GreaterThanEquals => leftValue.CompareTo(rightValue) >= 0,
                ComparisonOperatorType.LessThanEquals => leftValue.CompareTo(rightValue) <= 0,
                _ => leftValue.CompareTo(rightValue) == 0,
            };
        }
    }
}