public void UpdateView(OnChangeArgs e) {

        public void UpdateView(ResourceChangeArgs e) {

                        var modifier = new PermanentStatModifier<BlueTagUnit> {

                        var modifier = new StatModifier<BlueTagUnit> {

                        _affected.GetComponent<BlueTag>().AddPermanentCurrentModifier(modifier);

                        _affected.GetComponent<BlueTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);

                        var modifier = new PermanentStatModifier<RedTagUnit> {

                        var modifier = new StatModifier<RedTagUnit> {

                        _affected.GetComponent<RedTag>().AddPermanentCurrentModifier(modifier);

                        _affected.GetComponent<RedTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);

                        var modifier = new PermanentStatModifier<GreenTagUnit> {

                        var modifier = new StatModifier<GreenTagUnit> {

                        _affected.GetComponent<GreenTag>().AddPermanentCurrentModifier(modifier);

                        _affected.GetComponent<GreenTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);

    {
        public Unit<TUnitType> Amount { get; set; }
    }
    public class PermanentStatModifier<TUnitType> : IStatModifier<TUnitType> where TUnitType : IUnitType

    public class TransientStatModifier<TUnitType> : IStatModifier<TUnitType> where TUnitType : IUnitType

    public class StatModifier<TUnitType> : IStatModifier<TUnitType> where TUnitType : IUnitType

        public double ExpiryTime;
        public TransientStatModifier(double expiryTime) {
            ExpiryTime = expiryTime;
        }

using UnityEngine;

using System.Threading;

    public class PermanentStatModifierAccessor : IStatAccessor

    public class StatModifierAccessor : IStatAccessor

        public void AddCurrentModifier<TResource, TUnitType>(TResource resource, Unit<TUnitType> value) where TResource : Resource<TUnitType> where TUnitType : IUnitType {
            var modifier = new PermanentStatModifier<TUnitType> {
                Amount = value
            };

        CancellationToken _cancellationToken = CancellationToken.None;

            resource.AddPermanentCurrentModifier(modifier);
        }

        public static StatModifierAccessor Permanent = new(CancellationToken.None);

        public void AddCapacityModifier<TResource, TUnitType>(TResource resource, Unit<TUnitType> value) where TResource : Resource<TUnitType> where TUnitType : IUnitType {
            var modifier = new PermanentStatModifier<TUnitType> {
                Amount = value
            };
            resource.AddPermanentCapacityModifier(modifier);

        public StatModifierAccessor(CancellationToken cancellationToken) {
            _cancellationToken = cancellationToken;

    }
    public class TransientStatModifierAccessor : IStatAccessor
    {
        double _duration;
        public TransientStatModifierAccessor(double duration) {
            _duration = duration;
        }

            var modifier = new TransientStatModifier<TUnitType>(Time.timeAsDouble + _duration) {

            var modifier = new StatModifier<TUnitType> {

            resource.AddTransientCurrentModifier(modifier);

            resource.AddCurrentModifier(modifier, _cancellationToken);

            var modifier = new TransientStatModifier<TUnitType>(Time.timeAsDouble + _duration) {

            var modifier = new StatModifier<TUnitType> {

            resource.AddTransientCapacityModifier(modifier);

            resource.AddCapacityModifier(modifier, _cancellationToken);

        static readonly OnChangeArgs s_default = new(0, 1, null);

        static readonly ResourceChangeArgs s_default = new(0, 1, null);

                    _watchedResource.OnChanged -= OnChanged;

                    _watchedResource.ResourceChanged -= OnChanged;

                    _watchedResource.OnChanged += OnChanged;

                    _watchedResource.ResourceChanged += OnChanged;

        protected virtual void OnChanged(object sender, OnChangeArgs e) {

        protected virtual void OnChanged(object sender, ResourceChangeArgs e) {

using System.Collections;

using System.Linq;

using System.Threading;

        public OnChangeArgs Status => (OnChangeArgs)this;

        public ResourceChangeArgs Status => (ResourceChangeArgs)this;

            var value = _capacity.Value;

            var value = _capacity.Total;

        public void AddPermanentCapacityModifier(PermanentStatModifier<TUnitType> modifier) {
            _capacity.AddPermanentModifier(modifier);
            OnChanged?.Invoke(this, (OnChangeArgs)this);

        public void AddCapacityModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _capacity, cancelToken);

        public void AddTransientCapacityModifier(TransientStatModifier<TUnitType> modifier) {
            AddTransientModifier(modifier, _capacity);
        }

            var value = _current.Value;

            var value = _current.Total;

        public void AddPermanentCurrentModifier(PermanentStatModifier<TUnitType> modifier) {
            _current.AddPermanentModifier(modifier);
            OnChanged?.Invoke(this, (OnChangeArgs)this);

        public void AddCurrentModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _current, cancelToken);

        public void AddTransientCurrentModifier(TransientStatModifier<TUnitType> modifier) {
            AddTransientModifier(modifier, _current);
        }

        void AddTransientModifier<TStatType>(TransientStatModifier<TUnitType> modifier, Stat<TStatType> stat)

        void AddModifier<TStatType>(StatModifier<TUnitType> modifier, Stat<TStatType> stat, CancellationToken cancelToken)

            if (stat.AddTransientModifier(modifier)) {
                StartCoroutine(ExpireModifiers(modifier.ExpiryTime, stat));
            }

            cancelToken.Register(() => {
                OnResourceChanged((ResourceChangeArgs)this);
            });

            Debug.Log($"AddTransientModifier {transform.name}.{GetType().Name}.{typeof(TStatType).Name}");
            OnChanged?.Invoke(this, (OnChangeArgs)this);
        }

            stat.AddModifier(modifier, cancelToken);

        protected IEnumerator ExpireModifiers<TStatType>(double expiryTime, Stat<TStatType> stat)
            where TStatType : IStatType {
            var timeToWait = (float)(expiryTime - Time.timeAsDouble);
            yield return new WaitForSeconds(timeToWait);

            Debug.Log($"AddModifier {transform.name}.{GetType().Name}.{typeof(TStatType).Name}");
            OnResourceChanged((ResourceChangeArgs)this);
        }

            Debug.Log($"Retiring modifiers of {transform.name}.{GetType().Name}.{typeof(TStatType).Name} with expiry < {expiryTime}");
            stat.Retire(expiryTime);
            OnChanged?.Invoke(this, (OnChangeArgs)this);

        public event EventHandler<ResourceChangeArgs> ResourceChanged;
        public static explicit operator ResourceChangeArgs(Resource<TUnitType> resource) {
            return new((int)resource.GetCurrent(), (int)resource.GetCapacity(), resource.transform);

        public event EventHandler<OnChangeArgs> OnChanged;
        public static explicit operator OnChangeArgs(Resource<TUnitType> resource) {
            return new((int)resource.GetCurrent(), (int)resource.GetCapacity(), resource.transform);

        void OnResourceChanged(ResourceChangeArgs e) {
            ResourceChanged?.Invoke(this, e);

            List<TransientStatModifier<TUnitType>> _modifiers = new();
            HashSet<double> _expiry = new();

            LinkedList<StatModifier<TUnitType>> _modifiers = new();

            public Unit<TUnitType> Modified => _modifiers.Aggregate((Unit<TUnitType>)0, (acc, modifier) => acc + modifier.Amount);
            public Unit<TUnitType> Value => Base + Modified;

            /// <Summary>
            /// Adds a new permanent modifier to the stat. Taken into account in <paramref name="Base"/> property.
            /// </Summary>
            public void AddPermanentModifier(PermanentStatModifier<TUnitType> modifier) {
                Base += modifier.Amount;

            public Unit<TUnitType> Modified {
                get;
                private set;

            /// <Summary>
            /// Adds a new transient modifier to the stat. Taken into account in <paramref name="Modified"/>  and <paramref name="Value"/>  properties.
            /// </Summary>
            /// <returns>
            /// True when a transient modifier with a new expiry time is inserted.
            /// False when a transient modifier with the same expiry time is already present.
            /// </returns>
            public bool AddTransientModifier(TransientStatModifier<TUnitType> modifier) {
                _modifiers.Add(modifier);
                return _expiry.Add(modifier.ExpiryTime);

            public Unit<TUnitType> Total => Base + Modified;
            public void AddModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
                if (cancelToken == CancellationToken.None) {
                    Base += modifier.Amount;
                }
                else {
                    AddTransientModifier(modifier, cancelToken);
                }

            public void Retire(double expiryTime) {
                _modifiers = _modifiers.Where(modifier => modifier.ExpiryTime > expiryTime).ToList();
                _expiry.Remove(expiryTime);

            void AddTransientModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
                LinkedListNode<StatModifier<TUnitType>> node = new(modifier);
                _modifiers.AddFirst(node);
                Modified += modifier.Amount;
                cancelToken.Register(() => {
                    _modifiers.Remove(node);
                    Modified -= modifier.Amount;
                });

        public event EventHandler<OnChangeArgs> OnChanged;

        public event EventHandler<ResourceChangeArgs> ResourceChanged;

        public OnChangeArgs Status {

        public ResourceChangeArgs Status {

    public class OnChangeArgs : EventArgs

    public class ResourceChangeArgs : EventArgs

        public OnChangeArgs(int current, int capacity, Transform pawn) {

        public ResourceChangeArgs(int current, int capacity, Transform pawn) {

        public void UpdateView(OnChangeArgs e);

        public void UpdateView(ResourceChangeArgs e);

        public void UpdateView(OnChangeArgs e) {

        public void UpdateView(ResourceChangeArgs e) {

fileFormatVersion: 2
guid: 75d3569cf2cac3942ace199d3f57185a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

using System.Collections;
using TagFighter.Effects.Triggers;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public class PawnCondition : MonoBehaviour
    {
        public void Apply() {
            Debug.Log("Apply a new condition");
            Debug.Log($"Origin: {Origin} Caster: {Context.Caster} Target: {Context.EffectLocation}");
            Trigger.Register(this);
            StartCoroutine(SelfDestruct());
        }
        public void OnTrigger() {
            EffectInput data = new(Context, Context.GetAffectedUnits(), new PermanentStatModifierAccessor());
            foreach (var effect in Context.EffectsToTrigger) {
                effect.DelayedAction(data);
            }
            Destroy(this);
        }
    }
}
        }
        protected void OnDestroy() {
            Trigger.UnRegister();
        }
            yield return new WaitForSeconds((float)Duration);
        IEnumerator SelfDestruct() {
        double _duration;
        Transform _origin;
        EffectContext _context;
        ITrigger _trigger;
        public double Duration { get => _duration; set => _duration = value; }
        public Transform Origin { get => _origin; set => _origin = value; }
        public EffectContext Context { get => _context; set => _context = value; }
        public ITrigger Trigger { get => _trigger; set => _trigger = value; }

fileFormatVersion: 2
guid: 0ed9a99045057be48bae44742b4d2a00
folderAsset: yes
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

fileFormatVersion: 2
guid: 83af9b93e6ef2a24a964511656caa8e5
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

using System.Threading;
namespace TagFighter.Effects
{
    public class TransientPawnCondition : PawnCondition
    {
        CancellationTokenSource _cancellationSource;
        protected override void SetStatModifier() {
            _cancellationSource = new();
            StatModifier = new(_cancellationSource.Token);
        }
        protected override void OnDestroySpecific() {
            _cancellationSource.Cancel();
            _cancellationSource.Dispose();
        }
    }
}

fileFormatVersion: 2
guid: 75d3569cf2cac3942ace199d3f57185a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

using TagFighter.Effects.Triggers;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public class PawnCondition : MonoBehaviour
    {
        public Transform Origin { get; set; }
        public EffectContext Context { get; set; }
        public ITrigger ApplyTrigger { get; set; }
        public ITrigger EndTrigger { get; set; }
        protected StatModifierAccessor StatModifier;
        public void Apply() {
            Debug.Log("Apply a new condition");
            Debug.Log($"Origin: {Origin} Caster: {Context.Caster} Target: {Context.EffectLocation}");
            SetStatModifier();
            ApplyTrigger.Register(this);
            ApplyTrigger.TriggerConditionMet += ApplyTrigger_OnTriggerConditionMet;
            EndTrigger.Register(this);
            EndTrigger.TriggerConditionMet += EndTrigger_OnTriggerConditionMet;
        }
        protected virtual void SetStatModifier() {
            StatModifier = StatModifierAccessor.Permanent;
        }
        void EndTrigger_OnTriggerConditionMet(object sender, ConditionTriggerArgs e) {
            Debug.Log($"{nameof(EndTrigger_OnTriggerConditionMet)}");
            Destroy(this);
        }
        void ApplyTrigger_OnTriggerConditionMet(object sender, ConditionTriggerArgs e) {
            Debug.Log($"{nameof(ApplyTrigger_OnTriggerConditionMet)}");
            EffectInput data = new(Context, Context.GetAffectedUnits(), StatModifier);
            foreach (var effect in Context.EffectsToTrigger) {
                effect.DelayedAction(data);
            }
        }
        protected void OnDestroy() {
            ApplyTrigger.TriggerConditionMet -= ApplyTrigger_OnTriggerConditionMet;
            ApplyTrigger.UnRegister();
            EndTrigger.TriggerConditionMet -= EndTrigger_OnTriggerConditionMet;
            EndTrigger.UnRegister();
            OnDestroySpecific();
        }
        protected virtual void OnDestroySpecific() {
        }
    }
}

    public class ConditionTriggerArgs : EventArgs
    {
        public ConditionTriggerArgs() { }
    }

        public event EventHandler<ConditionTriggerArgs> TriggerConditionMet;

        [SerializeField]

        public event EventHandler<ConditionTriggerArgs> TriggerConditionMet;

            _resource.OnChanged += OnChanged;

            _resource.ResourceChanged += OnResourceChanged;

            _resource.OnChanged -= OnChanged;

            _resource.ResourceChanged -= OnResourceChanged;

        protected void OnChanged(object sender, OnChangeArgs e) {

        protected void OnResourceChanged(object sender, ResourceChangeArgs e) {

            Trigger(current, _beforeValue, Threshold);

            if (ShouldTrigger(current, _beforeValue, Threshold)) {
                OnTriggerConditionMet(new());
            }

        }

        protected void OnTriggerConditionMet(ConditionTriggerArgs e) {
            TriggerConditionMet?.Invoke(this, e);

        protected abstract void Trigger(int current, int before, int threshold);

        protected abstract bool ShouldTrigger(int current, int before, int threshold);

        protected override void Trigger(int current, int before, int threshold) {
            if (current > before + threshold) {
                Condition.OnTrigger();
            }

        protected override bool ShouldTrigger(int current, int before, int threshold) {
            return current > before + threshold;

        protected override void Trigger(int current, int before, int threshold) {
            if (current < before - threshold) {
                Condition.OnTrigger();
            }

        protected override bool ShouldTrigger(int current, int before, int threshold) {
            return current < before - threshold;

        public event EventHandler<ConditionTriggerArgs> TriggerConditionMet;

        public OnTimePass() { }

        public OnTimePass(float frequency) {
            _frequency = frequency;
        }

        protected void OnTriggerConditionMet(ConditionTriggerArgs e) {
            TriggerConditionMet?.Invoke(this, e);
        }

                _condition.OnTrigger();

                OnTriggerConditionMet(new());

                EffectInput data = new(context, Enumerable.Empty<Transform>(), new PermanentStatModifierAccessor());

                EffectInput data = new(context, Enumerable.Empty<Transform>(), StatModifierAccessor.Permanent);

            EffectInput data = new(context, context.GetAffectedUnits(), new PermanentStatModifierAccessor());

            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);

    public class TransientWeave : IImmediateEffect
    {
        public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Duration;
        public void ImmediateAction(EffectContext context, IEffect effect) {
            EffectInput data = new(context, context.GetAffectedUnits(), new PermanentStatModifierAccessor());
            if (effect != null) {
                effect.Apply(data);
                data.Affected = context.GetAffectedUnits();
            }
            /// Currently Duration is Context getter so there's only a single value in the iterator.
            /// To support get from pawns, requires somekind of aggregation operator from <see cref="IResourceOperator"/>
            /// to be included in this 
            var duration = Duration.Get(data).First();
            data.StatAccessor = new TransientStatModifierAccessor(duration);
            Materialize(data);
        }
        void Materialize(EffectInput data) {
            foreach (var effect in data.Context.EffectsToTrigger) {
                effect.DelayedAction(data);
            }
            data.Context.EffectsToTrigger.Clear();
        }
    }
    [Serializable]

        public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Duration;

        [SerializeReference, ShowSerializeReference]
        public Triggers.ITrigger ApplyTrigger;

        public Triggers.ITrigger Trigger;

        public Triggers.ITrigger EndTrigger;

        const double MinFrequency = 0.1;
        const double MaxDuration = 30;

        public bool IsPermanent;

            EffectInput data = new(context, context.GetAffectedUnits(), null);

            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);

            /// Currently Duration is Context getter so there's only a single value in the iterator.
            /// To support get from pawns, requires somekind of aggregation operator from <see cref="IResourceOperator"/>
            /// to be included in this 
            var duration = Duration.Get(data).First();
            duration = Math.Clamp(duration, MinFrequency, MaxDuration);

                var condition = affectedPawn.gameObject.AddComponent<PawnCondition>();
                condition.Duration = duration;
                condition.Trigger = Trigger.ShallowCopy();

                var condition = IsPermanent ? affectedPawn.gameObject.AddComponent<PawnCondition>() : affectedPawn.gameObject.AddComponent<TransientPawnCondition>();
                condition.EndTrigger = EndTrigger.ShallowCopy();
                condition.ApplyTrigger = ApplyTrigger.ShallowCopy();

  rune:

  Rune:

        Duration:
          Resource:
            rid: -2
          Location:
            rid: -2
          Multiplier: 1
          Addend: 5
        Trigger:
          rid: 4320157394915295259

        ApplyTrigger:
          rid: 4320157623323459587
        EndTrigger:
          rid: 4320157623323459588
        IsPermanent: 0

          rid: 4320157394915295262
    - rid: 4320157394915295259

          rid: 4320157623323459584
    - rid: 4320157623323459584
      type: {class: Current, ns: TagFighter.Effects.ResourceLocationAccessors.PawnProperties,
        asm: Assembly-CSharp}
    - rid: 4320157623323459587

    - rid: 4320157394915295262
      type: {class: Capacity, ns: TagFighter.Effects.ResourceLocationAccessors.PawnProperties,
        asm: Assembly-CSharp}

    - rid: 4320157623323459588
      type: {class: OnTimePass, ns: TagFighter.Effects.Triggers, asm: Assembly-CSharp}
      data:
        _frequency: 5

  rune:

  Rune:

          rid: 4320157394915295239

          rid: -2

    - rid: 4320157394915295239
      type: {class: OnResourceIncrease, ns: TagFighter.Effects.Triggers, asm: Assembly-CSharp}
      data:
        Resource:
          rid: 4320157394915295240
        Stat:
          rid: 4320157394915295263
        Threshold: 0
    - rid: 4320157394915295240
      type: {class: Pain, ns: TagFighter.Effects.ResourceTypeAccessors, asm: Assembly-CSharp}

        asm: Assembly-CSharp}
    - rid: 4320157394915295263
      type: {class: Capacity, ns: TagFighter.Effects.ResourceLocationAccessors.PawnProperties,

  m_LocalRotation: {x: 0.22914574, y: -0.070709124, z: 0.016692158, w: 0.970677}

  m_LocalRotation: {x: 0.22914574, y: -0.070709094, z: 0.016692149, w: 0.970677}

    m_SensorSize: {x: 2.271028, y: 1}

    m_SensorSize: {x: 2.1838007, y: 1}

  m_LocalRotation: {x: 0.22914574, y: -0.070709124, z: 0.016692158, w: 0.970677}

  m_LocalRotation: {x: 0.22914574, y: -0.070709094, z: 0.016692149, w: 0.970677}

csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion