caliverse_server/ServerCommon/Entity/Inventory/InventoryRule.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



using Amazon.Runtime.Internal.Transform;



using ServerCore; using ServerBase;



using SESSION_ID = System.Int32;
using WORLD_ID = System.UInt32;
using META_ID = System.UInt32;
using ENTITY_GUID = System.String;
using ACCOUNT_ID = System.String;
using OWNER_GUID = System.String;
using USER_GUID = System.String;
using CHARACTER_GUID = System.String;
using ITEM_GUID = System.String;



namespace ServerCommon
{
    public abstract class RuleBase
    {
        public HashSet<MetaAssets.EItemLargeType> EquipableItemLargeTypes { get; set; } = new();

        public HashSet<MetaAssets.EItemSmallType> EquipableItemSmallTypes { get; set; } = new();

        public EntityDynamoDbSortKeyType EntitySKType { get; set; } = EntityDynamoDbSortKeyType.None;

        public RuleBase() { }
    }

    public class BagRule : RuleBase
    {
        public InvenBagType InvenBagType { get; set; } = InvenBagType.None;

        public BagTabType UsableBagTabType { get; set; } = BagTabType.None;


        public BagRule()
        { }
    }

    public abstract class EquipRuleBase : RuleBase 
    {
        public InvenEquipType InvenEquipType { get; set; } = InvenEquipType.None;

        public abstract Result onConfigure(InvenEquipType equipType);
    }

    public class ToolEquipRule : EquipRuleBase
    {
        public List<ToolSlotType> UsableToolSlotTypes { get; set; } = new();

        public ToolEquipRule()
        { }

        public override Result onConfigure(InvenEquipType equipType)
        {
            var result = new Result();
            var err_msg = string.Empty;

            foreach (var item_large_type in equipType.toEquipableItemLargeTypes())
            {
                if (false == EquipableItemLargeTypes.Add(item_large_type))
                {
                    err_msg = $"Failed to Add() EquipableItemLargeTypes !!!, duplicated EItemLargeType : EItemLargeType:{item_large_type} - InvenEquipType:{equipType}";
                    result.setFail(ServerErrorCode.ToolEquipRuleItemLargeTypeDuplicated, err_msg);
                    Log.getLogger().error(result.toBasicString());

                    return result;
                }

                UsableToolSlotTypes = equipType.toEquipableToolSlotTypes();
            }

            return result;
        }
    }

    public class ClothEquipRule : EquipRuleBase
    {
        public Dictionary<ClothSlotType, List<MetaAssets.EItemSmallType>> m_slots_by_cloth_slot_type = new();
        public Dictionary<MetaAssets.EItemSmallType, List<ClothSlotType>> m_slots_by_item_type = new();

        public ClothEquipRule()
        { }

        public override Result onConfigure(InvenEquipType equipType)
        {
            var result = new Result();
            var err_msg = string.Empty;

            foreach (var item_large_type in equipType.toEquipableItemLargeTypes())
            {
                if (false == EquipableItemLargeTypes.Add(item_large_type))
                {
                    err_msg = $"Failed to Add() EquipableItemLargeTypes !!!, duplicated EItemLargeType : EItemLargeType:{item_large_type} - InvenEquipType:{equipType}";
                    result.setFail(ServerErrorCode.ClothEquipRuleItemLargeTypeDuplicated, err_msg);
                    Log.getLogger().error(result.toBasicString());

                    return result;
                }

                var cloth_slot_types = EnumHelper.getValuesWithoutScopeAll<ClothSlotType>();
                foreach(var slot_type in cloth_slot_types)
                {
                    if (false == m_slots_by_cloth_slot_type.TryGetValue(slot_type, out var found_item_small_types))
                    {
                        found_item_small_types = new List<MetaAssets.EItemSmallType>();
                        m_slots_by_cloth_slot_type.Add(slot_type, found_item_small_types);
                    }
                    found_item_small_types = equipType.toEquipableItemSmallTypesWithClothSlotType(slot_type);

                    foreach(var item_small_type in found_item_small_types)
                    {
                        if (false == m_slots_by_item_type.TryGetValue(item_small_type, out var found_slot_types))
                        {
                            found_slot_types = new List<ClothSlotType>();
                            m_slots_by_item_type.Add(item_small_type, found_slot_types);
                        }
                        if(false == found_slot_types.Exists(x => x == slot_type))
                        {
                            found_slot_types.Add(slot_type);
                        }

                        EquipableItemSmallTypes.Add(item_small_type);
                    }
                }                
            }

            return result;
        }
    }

    public class TattooEquipRule : EquipRuleBase
    {
        public List<TattooSlotType> UsableTattooSlotPosOfDefault { get; set; } = new();

        public List<TattooSlotType> UsableTattooSlotPosOfUgcNpc { get; set; } = new();

        public TattooEquipRule()
        { }

        public override Result onConfigure(InvenEquipType equipType)
        {
            var result = new Result();
            var err_msg = string.Empty;

            foreach (var item_large_type in equipType.toEquipableItemLargeTypes())
            {
                if (false == EquipableItemLargeTypes.Add(item_large_type))
                {
                    err_msg = $"Failed to Add() EquipableItemLargeTypes !!!, duplicated EItemLargeType : EItemLargeType:{item_large_type} - InvenEquipType:{equipType}";
                    result.setFail(ServerErrorCode.TattooEquipRuleItemLargeTypeDuplicated, err_msg);
                    Log.getLogger().error(result.toBasicString());

                    return result;
                }

                UsableTattooSlotPosOfDefault = equipType.toEquipableTattooSlotTypes();
                UsableTattooSlotPosOfUgcNpc = equipType.toEquipableTattooSlotTypes(EntityType.UgcNpc);
            }

            return result;
        }

        public List<TattooSlotType> getUsableTattooSlotPos(EntityType entityType)
        {
            if(   EntityType.UgcNpc == entityType
               || EntityType.Beacon == entityType )
            {
                return UsableTattooSlotPosOfUgcNpc;
            }

            return UsableTattooSlotPosOfDefault;
        }
    }

    public class InventoryRule : IRule
    {
        private readonly Dictionary<InvenBagType, BagRule> m_bag_rules = new();
        private readonly Dictionary<MetaAssets.EItemLargeType, List<BagRule>> m_bag_rules_by_item_type = new();
        private readonly Dictionary<InvenEquipType, EquipRuleBase> m_equip_rule_bases = new();
        private readonly Dictionary<MetaAssets.EItemLargeType, List<EquipRuleBase>> m_equip_rule_bases_by_item_type = new();

        public InventoryRule()
        {
        }

        public async Task<Result> onInit()
        {
            var result = await configure();
            if(result.isFail())
            {
                return result;
            }

            return result;
        }

        public async Task<Result> configure()
        {
            var result = new Result();
            var err_msg = string.Empty;

            var inven_bag_type_enums = EnumHelper.getValuesWithoutScopeAll<InvenBagType>();
            foreach(var value in inven_bag_type_enums)
            {
                var bag_rule = new BagRule();
                bag_rule.InvenBagType = value;
                foreach(var item_type in value.toEquipableItemLargeTypes())
                {
                    if(false == bag_rule.EquipableItemLargeTypes.Add(item_type))
                    {
                        err_msg = $"Failed to Add() EquipableItemLargeTypes !!!, duplicated EItemLargeType : EItemLargeType:{item_type} - InvenBagType:{value}";                        
                        result.setFail(ServerErrorCode.BagRuleItemLargeTypeDuplicated, err_msg);
                        Log.getLogger().error(result.toBasicString());
                        return result;
                    }
                }
                bag_rule.UsableBagTabType = value.toUsableBagTabType();
                m_bag_rules.Add(value, bag_rule);
            }

            var item_type_to_bag_types = EnumHelper.getValuesWithoutScopeAll<MetaAssets.EItemLargeType>();
            foreach (var item_type in item_type_to_bag_types)
            {
                foreach(var eache in m_bag_rules)
                {
                    if(false == eache.Value.EquipableItemLargeTypes.Contains(item_type))
                    {
                        continue;
                    }
                    if(false == m_bag_rules_by_item_type.TryGetValue(item_type, out var found_bag_rules))
                    {
                        found_bag_rules = new List<BagRule>();
                        m_bag_rules_by_item_type.Add(item_type, found_bag_rules);
                    }
                    found_bag_rules.Add(eache.Value);
                }
            }

            var inven_equip_type_enums = EnumHelper.getValuesWithoutScopeAll<InvenEquipType>();
            foreach (var value in inven_equip_type_enums)
            {
                var equip_rule_base = newEquipRuleBaseByInvenEquipType(value);
                if (equip_rule_base == null)
                    continue;

                equip_rule_base.InvenEquipType = value;
                result = equip_rule_base.onConfigure(value);
                if(result.isFail())
                {
                    return result;
                }
                equip_rule_base.EntitySKType = value.toEntitySKType();
                m_equip_rule_bases.Add(value, equip_rule_base);
            }

            var item_type_to_equip_types = EnumHelper.getValuesWithoutScopeAll<MetaAssets.EItemLargeType>();
            foreach (var item_type in item_type_to_equip_types)
            {
                foreach (var eache in m_equip_rule_bases)
                {
                    if (false == eache.Value.EquipableItemLargeTypes.Contains(item_type))
                    {
                        continue;
                    }
                    if (false == m_equip_rule_bases_by_item_type.TryGetValue(item_type, out var found_equip_rule_bases))
                    {
                        found_equip_rule_bases = new List<EquipRuleBase>();
                        m_equip_rule_bases_by_item_type.Add(item_type, found_equip_rule_bases);
                    }
                    found_equip_rule_bases.Add(eache.Value);
                }
            }

            return await Task.FromResult(result);
        }

        public EquipRuleBase? newEquipRuleBaseByInvenEquipType(InvenEquipType equipType) 
        {
            switch(equipType) 
            {
                case InvenEquipType.Tool:
                    return new ToolEquipRule();

                case InvenEquipType.Cloth:
                    return new ClothEquipRule();

                case InvenEquipType.Tattoo:
                    return new TattooEquipRule();

                default:
                    var err_msg = $"Failed to newEquipRuleBaseByInvenEquipType() !!!, Invalid InvenEquipType : InvenEquipType:{equipType}";
                    Log.getLogger().error(err_msg);
                    return null;
            }
        }

        public BagRule? getBagRuleByInvenBagType(InvenBagType bagType)
        {
            m_bag_rules.TryGetValue(bagType, out var found_bag_rules);
            return found_bag_rules;
        }

        public EquipRuleBase? getEquipRuleBaseByInvenEquipType(InvenEquipType equipType)
        {
            m_equip_rule_bases.TryGetValue(equipType, out var found_equip_rule_bases);
            return found_equip_rule_bases;
        }

        public List<BagRule>? getBagRulesByItemLargeType(MetaAssets.EItemLargeType itemType)
        {
            m_bag_rules_by_item_type.TryGetValue(itemType, out var found_bag_rules);
            return found_bag_rules;
        }

        public List<EquipRuleBase>? getEquipRuleBasesByItemLargeType(MetaAssets.EItemLargeType itemType)
        {
            m_equip_rule_bases_by_item_type.TryGetValue(itemType, out var found_equip_rule_bases);
            return found_equip_rule_bases;
        }

        public Dictionary<InvenBagType, BagRule> getBagRules() => m_bag_rules;

        public Dictionary<InvenEquipType, EquipRuleBase> getEquipRuleBases() => m_equip_rule_bases;
    }
}