ModifierPool.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Loot.Api.Attributes;
using Loot.Api.Content;
using Loot.Api.Ext;
using Loot.Api.Loaders;
using Terraria;
using Terraria.ModLoader;
using Terraria.ModLoader.IO;

namespace Loot.Api.Core
{
    [DoNotLoad]
    public class FiniteModifierPool : ModifierPool
    {
        public readonly List<Modifier> Modifiers;

        public FiniteModifierPool(List<Modifier> modifiers)
        {
            Modifiers = modifiers ?? new List<Modifier>();
        }

        public void Apply(Item item)
        {
            Modifiers.ForEach(mod => mod.Apply(item));
        }
    }

    public abstract class ModifierPool : ILoadableContent, ILoadableContentSetter, ICloneable
    {
        public Mod Mod { get; internal set; }

        Mod ILoadableContentSetter.Mod
        {
            set => Mod = value;
        }

        public uint Type { get; internal set; }

        uint ILoadableContentSetter.Type
        {
            set => Type = value;
        }

        public string Name => GetType().Name;

        private PopulatePoolFromAttribute _populatePoolFrom;

        internal void CacheAttributes()
        {
            _populatePoolFrom = GetType().GetCustomAttribute<PopulatePoolFromAttribute>(true);
        }

        private IEnumerable<Modifier> _GetModifiers()
        {
            if (_populatePoolFrom != null)
            {
                var classes = _populatePoolFrom.GetClasses().SelectMany(x => x.Value);

                foreach (var @class in classes)
                {
                    var m = ContentLoader.Modifier.GetContent(@class);
                    if (m != null)
                    {
                        yield return m;
                    }
                }
            }

            foreach (Modifier m in GetModifiers())
            {
                if (m != null)
                {
                    yield return m;
                }
            }
        }

        public virtual IEnumerable<Modifier> GetModifiers()
            => Enumerable.Empty<Modifier>();

        protected internal IEnumerable<Modifier> GetRollableModifiers(ModifierContext ctx)
            => _GetModifiers().Where(x => x._CanRoll(ctx));

        //public float TotalRarityLevel
        //  => ActiveModifiers.Select(m => m.Properties.RarityLevel).DefaultIfEmpty(0).Sum();

        //public IEnumerable<ModifierTooltipLine[]> Description
        //  => ActiveModifiers.Select(m => m.GetTooltip().Build().ToArray());

        public virtual float RollChance => 1f;

        //internal float ModifierRollChance(int len) => 0.5f / (float)Math.Pow(2, len);

        protected internal bool _CanRoll(ModifierContext ctx)
            => CanRoll(ctx);

        public virtual bool CanRoll(ModifierContext ctx)
            => ctx.Item?.IsModifierRollableItem() ?? true;

        internal void ApplyModifiers(Item item)
        {
            //foreach (Modifier m in ActiveModifiers)
            //{
            //  m.Apply(item);
            //}
        }

        public virtual void Clone(ref ModifierPool clone)
        {
        }

        public object Clone()
        {
            ModifierPool clone = (ModifierPool)MemberwiseClone();
            clone.Type = Type;
            clone.Mod = Mod;
            //clone.ActiveModifiers =
            //  ActiveModifiers?
            //      .Select(x => (Modifier)x?.Clone() ?? Loot.Instance.GetNullModifier())
            //      .ToArray();
            Clone(ref clone);
            return clone;
        }

        public virtual void NetReceive(Item item, BinaryReader reader)
        {
        }

        public virtual void NetSend(Item item, BinaryWriter writer)
        {
        }

        public virtual void Load(Item item, TagCompound tag)
        {
        }

        public virtual void Save(Item item, TagCompound tag)
        {
        }
    }
}