RelatedItem.cs

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Xna.Framework;
using Barotrauma.Extensions;
 
namespace Barotrauma
{
    class RelatedItem
    {
        public enum RelationType
        {
            None,
            Contained,
            Equipped,
            Picked,
            Container,
            Invalid
        }
 
        public bool MatchOnEmpty { get; set; }
 
        public bool RequireEmpty { get; set; }
 
        private bool RequireOrMatchOnEmpty => MatchOnEmpty || RequireEmpty;
 
        public bool IgnoreInEditor { get; set; }
 
 
        public ImmutableHashSet<Identifier> ExcludedIdentifiers { get; private set; }
 
        private readonly RelationType type;
 
        public List<StatusEffect> StatusEffects = new List<StatusEffect>();
 
        public LocalizedString Msg;
 
        public Identifier MsgTag;
 
        public bool ExcludeBroken { get; private set; }
 
        public bool ExcludeFullCondition { get; private set; }
 
        public bool AllowVariants { get; private set; } = true;
 
        public RelationType Type
        {
            get { return type; }
        }
 
        public int TargetSlot = -1;
 
        public InvSlotType CharacterInventorySlotType;
 
        public Vector2? ItemPos;
 
        public bool Hide;
 
        public float Rotation;
 
        public bool SetActive;
 
        public bool BlameEquipperForDeath;
 
        public bool IsOptional { get; set; }
 
        public string JoinedIdentifiers
        {
            get => Identifiers.ConvertToString();
            set => Identifiers = value.ToIdentifiers().ToImmutableHashSet();
        }
 
        public ImmutableHashSet<Identifier> Identifiers { get; private set; }
 
        public string JoinedExcludedIdentifiers
        {
            get => ExcludedIdentifiers.ConvertToString();
            set => ExcludedIdentifiers = value.ToIdentifiers().ToImmutableHashSet();
        }
 
        public bool MatchesItem(Item item)
        {
            if (item == null) { return false; }
            if (ExcludedIdentifiers.Contains(item.Prefab.Identifier)) { return false; }
            foreach (var excludedIdentifier in ExcludedIdentifiers)
            {
                if (item.HasTag(excludedIdentifier)) { return false; }
            }
            if (item.ParentInventory?.Owner is Character character && CharacterInventorySlotType != InvSlotType.None)
            {
                if (!character.HasEquippedItem(item, CharacterInventorySlotType)) { return false; }
            }
            if (Identifiers.Contains(item.Prefab.Identifier)) { return true; }
            foreach (var identifier in Identifiers)
            {
                if (item.HasTag(identifier)) { return true; }
            }
            if (AllowVariants && !item.Prefab.VariantOf.IsEmpty)
            {
                if (Identifiers.Contains(item.Prefab.VariantOf)) { return true; }
            }
            return false;
        }
        public bool MatchesItem(ItemPrefab itemPrefab)
        {
            if (itemPrefab == null) { return false; }
            if (ExcludedIdentifiers.Contains(itemPrefab.Identifier)) { return false; }
            foreach (var excludedIdentifier in ExcludedIdentifiers)
            {
                if (itemPrefab.Tags.Contains(excludedIdentifier)) { return false; }
            }
            if (Identifiers.Contains(itemPrefab.Identifier)) { return true; }
            foreach (var identifier in Identifiers)
            {
                if (itemPrefab.Tags.Contains(identifier)) { return true; }
            }
            if (AllowVariants && !itemPrefab.VariantOf.IsEmpty)
            {
                if (Identifiers.Contains(itemPrefab.VariantOf)) { return true; }
            }
            return false;
        }
 
        public RelatedItem(Identifier[] identifiers, Identifier[] excludedIdentifiers)
        {
            this.Identifiers = identifiers.Select(id => id.Value.Trim().ToIdentifier()).ToImmutableHashSet();
            this.ExcludedIdentifiers = excludedIdentifiers.Select(id => id.Value.Trim().ToIdentifier()).ToImmutableHashSet();
        }
 
        public RelatedItem(ContentXElement element, string parentDebugName)
        {
            Identifier[] identifiers;
            if (element.GetAttribute("name") != null)
            {
                //backwards compatibility + a console warning
                DebugConsole.ThrowError($"Error in RelatedItem config (" + (string.IsNullOrEmpty(parentDebugName) ? element.ToString() : parentDebugName) + ") - use item tags or identifiers instead of names.", contentPackage: element.ContentPackage);
                Identifier[] itemNames = element.GetAttributeIdentifierArray("name", Array.Empty<Identifier>());
                //attempt to convert to identifiers and tags
                List<Identifier> convertedIdentifiers = new List<Identifier>();
                foreach (Identifier itemName in itemNames)
                {
                    var matchingItem = ItemPrefab.Prefabs.Find(me => me.Name == itemName.Value);
                    if (matchingItem != null)
                    {
                        convertedIdentifiers.Add(matchingItem.Identifier);
                    }
                    else
                    {
                        //no matching item found, this must be a tag
                        convertedIdentifiers.Add(itemName);
                    }
                }
                identifiers = convertedIdentifiers.ToArray();
            }
            else
            {
                identifiers = element.GetAttributeIdentifierArray("items", null) ?? element.GetAttributeIdentifierArray("item", null);
                if (identifiers == null)
                {
                    identifiers = element.GetAttributeIdentifierArray("identifiers", null) ?? element.GetAttributeIdentifierArray("tags", null);
                    if (identifiers == null)
                    {
                        identifiers = element.GetAttributeIdentifierArray("identifier", null) ?? element.GetAttributeIdentifierArray("tag", Array.Empty<Identifier>());
                    }
                }
            }
            this.Identifiers = identifiers.ToImmutableHashSet();
 
            Identifier[] excludedIdentifiers = element.GetAttributeIdentifierArray("excludeditems", null) ?? element.GetAttributeIdentifierArray("excludeditem", null);
            if (excludedIdentifiers == null)
            {
                excludedIdentifiers = element.GetAttributeIdentifierArray("excludedidentifiers", null) ?? element.GetAttributeIdentifierArray("excludedtags", null);
                if (excludedIdentifiers == null)
                {
                    excludedIdentifiers = element.GetAttributeIdentifierArray("excludedidentifier", null) ?? element.GetAttributeIdentifierArray("excludedtag", Array.Empty<Identifier>());
                }
            }
            this.ExcludedIdentifiers = excludedIdentifiers.ToImmutableHashSet();
 
            ExcludeBroken = element.GetAttributeBool("excludebroken", true);
            RequireEmpty = element.GetAttributeBool("requireempty", false);
            ExcludeFullCondition = element.GetAttributeBool("excludefullcondition", false);
            AllowVariants = element.GetAttributeBool("allowvariants", true);
            Rotation = element.GetAttributeFloat("rotation", 0f);
            SetActive = element.GetAttributeBool("setactive", false);
            BlameEquipperForDeath = element.GetAttributeBool(nameof(BlameEquipperForDeath), false);
 
            CharacterInventorySlotType = element.GetAttributeEnum(nameof(CharacterInventorySlotType), InvSlotType.None);
 
            if (element.GetAttribute(nameof(Hide)) != null)
            {
                Hide = element.GetAttributeBool(nameof(Hide), false);
            }
            if (element.GetAttribute(nameof(ItemPos)) != null)
            {
                ItemPos = element.GetAttributeVector2(nameof(ItemPos), Vector2.Zero);
            }
            string typeStr = element.GetAttributeString("type", "");
            if (string.IsNullOrEmpty(typeStr))
            {
                switch (element.Name.ToString().ToLowerInvariant())
                {
                    case "containable":
                        typeStr = "Contained";
                        break;
                    case "suitablefertilizer":
                    case "suitableseed":
                        typeStr = "None";
                        break;
                }
            }
            if (!Enum.TryParse(typeStr, true, out type))
            {
                DebugConsole.ThrowError("Error in RelatedItem config (" + parentDebugName + ") - \"" + typeStr + "\" is not a valid relation type.", contentPackage: element.ContentPackage);
                type = RelationType.Invalid;
            }
 
            MsgTag = element.GetAttributeIdentifier("msg", Identifier.Empty);
            LocalizedString msg = TextManager.Get(MsgTag);
            if (!msg.Loaded)
            {
                Msg = MsgTag.Value;
            }
            else
            {
#if CLIENT
                foreach (InputType inputType in Enum.GetValues(typeof(InputType)))
                {
                    string inputTag = $"[{inputType.ToString().ToLowerInvariant()}]";
                    if (!msg.Contains(inputTag)) { continue; }
                    msg = msg.Replace(inputTag, GameSettings.CurrentConfig.KeyMap.KeyBindText(inputType));
                }
                Msg = msg;
#endif
            }
 
            foreach (var subElement in element.Elements())
            {
                if (!subElement.Name.ToString().Equals("statuseffect", StringComparison.OrdinalIgnoreCase)) { continue; }
                StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
            }
 
            IsOptional = element.GetAttributeBool("optional", false);
            IgnoreInEditor = element.GetAttributeBool("ignoreineditor", false);
            MatchOnEmpty = element.GetAttributeBool("matchonempty", false);
            TargetSlot = element.GetAttributeInt("targetslot", -1);
 
        }
 
        public bool CheckRequirements(Character character, Item parentItem)
        {
            switch (type)
            {
                case RelationType.Contained:
                    if (parentItem == null) { return false; }
                    return CheckContained(parentItem);
                case RelationType.Container:
                    if (parentItem == null || parentItem.Container == null) { return MatchOnEmpty || RequireEmpty; }
                    return CheckItem(parentItem.Container, this);
                case RelationType.Equipped:
                    if (character == null) { return false; }
                    var heldItems = character.HeldItems;
                    if (RequireOrMatchOnEmpty && heldItems.None()) { return true; }
                    foreach (Item equippedItem in heldItems)
                    {
                        if (equippedItem == null) { continue; }
                        if (CheckItem(equippedItem, this))
                        {
                            if (RequireEmpty && equippedItem.Condition > 0) { return false; }
                            return true;
                        }
                    }
                    break;
                case RelationType.Picked:
                    if (character == null) { return false; }
                    if (character.Inventory == null) { return MatchOnEmpty || RequireEmpty; }
                    var allItems = character.Inventory.AllItems;
                    if (RequireOrMatchOnEmpty && allItems.None()) { return true; }
                    foreach (Item pickedItem in allItems)
                    {
                        if (pickedItem == null) { continue; }
                        if (CheckItem(pickedItem, this))
                        {
                            if (RequireEmpty && pickedItem.Condition > 0) { return false; }
                            return true;
                        }
                    }
                    break;
                default:
                    return true;
            }
 
            static bool CheckItem(Item i, RelatedItem ri) => (!ri.ExcludeBroken || ri.RequireEmpty || i.Condition > 0.0f) && (!ri.ExcludeFullCondition || !i.IsFullCondition) && ri.MatchesItem(i);
 
            return false;
        }
 
        private bool CheckContained(Item parentItem)
        {
            if (parentItem.OwnInventory == null) { return false; }
 
            if (TargetSlot == -1 && RequireOrMatchOnEmpty)
            {
                bool isEmpty = parentItem.OwnInventory.IsEmpty();
                if (RequireEmpty) { return isEmpty; }
                if (MatchOnEmpty && isEmpty) { return true; }
            }
            foreach (var container in parentItem.GetComponents<Items.Components.ItemContainer>())
            {
                if (TargetSlot > -1 && RequireOrMatchOnEmpty)
                {
                    var itemInSlot = container.Inventory.GetItemAt(TargetSlot);
                    if (RequireEmpty) { return itemInSlot == null; }
                    if (MatchOnEmpty && itemInSlot == null) { return true; }
                }
                foreach (Item contained in container.Inventory.AllItems)
                {
                    if (TargetSlot > -1 && parentItem.OwnInventory.FindIndex(contained) != TargetSlot) { continue; }
                    if ((!ExcludeBroken || contained.Condition > 0.0f) && (!ExcludeFullCondition || !contained.IsFullCondition) && MatchesItem(contained)) { return true; }
                    if (CheckContained(contained)) { return true; }
                }
            }
            return false;
        }
 
        public void Save(XElement element)
        {
            element.Add(
                new XAttribute("items", JoinedIdentifiers),
                new XAttribute("type", type.ToString()), 
                new XAttribute("characterinventoryslottype", CharacterInventorySlotType.ToString()),
                new XAttribute("optional", IsOptional),
                new XAttribute("ignoreineditor", IgnoreInEditor),
                new XAttribute("excludebroken", ExcludeBroken),
                new XAttribute("requireempty", RequireEmpty),
                new XAttribute("excludefullcondition", ExcludeFullCondition),
                new XAttribute("targetslot", TargetSlot),
                new XAttribute("allowvariants", AllowVariants),
                new XAttribute("rotation", Rotation),
                new XAttribute("setactive", SetActive));
 
            if (Hide)
            {
                element.Add(new XAttribute(nameof(Hide), true));
            }
            if (ItemPos.HasValue)
            {
                element.Add(new XAttribute(nameof(ItemPos), ItemPos.Value));
            }
 
            if (ExcludedIdentifiers.Count > 0)
            {
                element.Add(new XAttribute("excludedidentifiers", JoinedExcludedIdentifiers));
            }
 
            if (!Msg.IsNullOrWhiteSpace()) { element.Add(new XAttribute("msg", MsgTag.IsEmpty ? Msg : MsgTag.Value)); }
        }
 
        public static RelatedItem Load(ContentXElement element, bool returnEmpty, string parentDebugName)
        {           
            RelatedItem ri = new RelatedItem(element, parentDebugName);
            if (ri.Type == RelationType.Invalid) { return null; }
            if (ri.Identifiers.None() && ri.ExcludedIdentifiers.None() && !returnEmpty) { return null; }
            return ri;
        }
    }
}