itai.sharim/TagFight - Change NPTXIY5PL7XQUOFJ2WRAZUBHMC4OFZVF4EA74GBI63TJ4QXDKMAAC

Add ProvideSourceInfo to many Serially serialized classes

Created by itai.sharim on July 8, 2023

NPTXIY5PL7XQUOFJ2WRAZUBHMC4OFZVF4EA74GBI63TJ4QXDKMAAC

Dependencies

In channels

main

Change contents

Replacement in Assets/Scripts/Systems/Effects/EffectSystem.cs at line 1 [3.2503]

B:BD[3.2503] → [2.355:8203]

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TagFighter.Resources;
using UnityEngine;
[Serializable]
public class EffectSystem : IEffectSystem
{
    ParticleSystem _rippleOutVfx;
    [SerializeField] TagFighter.Effects.EffectColors _colorMapping;
    const string PulseMaterial = "Materials/PulseMaterial2";
    class EffectRunner : MonoBehaviour
    {
        public GameObject EffectObj;
        public Material Material;
        public float PlayTime;
        public void Run(GameObject effectObj, Material material, float playTime) {
            EffectObj = effectObj;
            Material = material;
            PlayTime = playTime;
            Material.SetFloat("_Phase", 0);
            EffectObj.SetActive(true);
            StartCoroutine("PlayEffect");
        }
        public IEnumerator PlayEffect() {
            float totalTime = 0;
            float phase = 0;
            while (phase < 0.98) {
                totalTime += Time.deltaTime;
                phase = totalTime / PlayTime;
                Material.SetFloat("_Phase", phase);
                yield return null;
            }
            Destroy(EffectObj);
        }
    }
    public EffectSystem() {
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        switch (areaOfEffect) {
            case SingleTarget: ApplyTagsEffectSingle(); break;
            case CircleArea aoe: ApplyTagsEffectRadius(tags, origin, direction, aoe); break;
            case ConeArea aoe: ApplyTagsEffectCone(tags, origin, direction, aoe); break;
            case PathArea aoe: ApplyTagsEffectPath(tags, origin, direction, aoe); break;
        }
    }
    void ApplyTagsEffectSingle() {
        Debug.Log("ApplyTagsEffectSingle");
    }
    void ApplyTagsEffectPath(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, PathArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateQuadMeshForUnit(origin, areaOfEffect.Width, areaOfEffect.Length);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectRadius(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, CircleArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, 360, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectCone(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, ConeArea areaOfEffect) {
        Debug.Log("ApplyTagsEffectCone");
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, areaOfEffect.Angle, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("GetEffectColor");
        var color = new Color();
        Debug.Log($"GetEffectColor length {tags.Count()}");
        if (_colorMapping == null) {
            foreach (var tag in tags) {
                Debug.Log("GetEffectColor tag");
                if (_colorMapping.ContainsKey(tag.Item1)) {
                    Debug.Log("GetEffectColor mapping found");
                    var mappedColor = _colorMapping[tag.Item1];
                    // TODO: scale color by amount
                    color += mappedColor;
                }
            }
        }
        Debug.Log("GetEffectColor Finished");
        return color;
    }
    public Mesh CreateArcMeshForUnit(Transform unit, float arc, float length, int numberOfVerticesInArc = 100) {
        return CreateArcMesh(unit.forward, arc, length, numberOfVerticesInArc, Vector3.up);
    }
    public Mesh CreateQuadMeshForUnit(Transform unit, float width, float length) {
        return CreateQuadMesh(unit.forward, width, length, Vector3.up);
    }
    void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh, Material material) {
        GameObject effectObj = new();
        effectObj.SetActive(false);
        effectObj.transform.position = originUnit.position;
        effectObj.transform.rotation = direction;
        var meshRenderer = effectObj.AddComponent<MeshRenderer>();
        meshRenderer.sharedMaterial = material;
        meshRenderer.shadowCastingMode = 0;
        meshRenderer.receiveShadows = false;
        var meshFilter = effectObj.AddComponent<MeshFilter>();
        meshFilter.mesh = mesh;
        effectObj.AddComponent<EffectRunner>();
        var effectRunner = effectObj.GetComponent<EffectRunner>();
        effectRunner.Run(effectObj, material, 1f);
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        var origin = Vector3.zero;
        Mesh mesh = new();
        var n = numberOfVerticesInArc + 1;
        var arcStep = arc / (n - 2);
        var currentDegrees = -arc / 2;
        var vertices = new Vector3[n];
        var uv = new Vector2[n];
        vertices[0] = origin;
        uv[0] = origin;
        for (var i = 1; i < n; i++) {
            vertices[i] = Quaternion.AngleAxis(currentDegrees, rotationAxis) * direction * length;
            uv[i] = new Vector2(0, 1);
            //Debug.Log($"Current Degrees: {currentDegrees} -> {vertices[i]}");
            currentDegrees += arcStep;
        }
        mesh.vertices = vertices;
        mesh.uv = uv;
        var tris = new int[(n - 2) * 3];
        for (var i = 0; i < n - 2; i++) {
            tris[i * 3] = 0;
            tris[i * 3 + 1] = i + 1;
            tris[i * 3 + 2] = i + 2;
        }
        mesh.triangles = tris;
        var normals = new Vector3[n];
        for (var i = 0; i < n; i++) {
            normals[i] = rotationAxis;
        }
        mesh.normals = normals;
        return mesh;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Mesh mesh = new();
        var origin = Vector3.zero;
        // TODO: how to calculate local rotation? direction
        var vertices = new Vector3[4]
        {
            new Vector3(-width/2, 0, 0) + origin,
            new Vector3(width/2, 0, 0) + origin,
            new Vector3(-width/2, 0, length) + origin,
            new Vector3(width/2, 0, length) + origin
        };
        mesh.vertices = vertices;
        var tris = new int[6]
        {
            // lower left triangle
            0, 2, 1,
            // upper right triangle
            2, 3, 1
        };
        mesh.triangles = tris;
        var normals = new Vector3[4]
        {
            rotationAxis,
            rotationAxis,
            rotationAxis,
            rotationAxis
        };
        mesh.normals = normals;
        var uv = new Vector2[4]
        {
            new Vector2(0, 0),
            new Vector2(1, 0),
            new Vector2(0, 1),
            new Vector2(1, 1)
        };
        mesh.uv = uv;
        return mesh;
    }
}

[3.2503]

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
[ProvideSourceInfo]
[Serializable]
public class EffectSystem : IEffectSystem
{
    ParticleSystem _rippleOutVfx;
    [SerializeField] TagFighter.Effects.EffectColors _colorMapping;
    const string PulseMaterial = "Materials/PulseMaterial2";
    class EffectRunner : MonoBehaviour
    {
        public GameObject EffectObj;
        public Material Material;
        public float PlayTime;
        public void Run(GameObject effectObj, Material material, float playTime) {
            EffectObj = effectObj;
            Material = material;
            PlayTime = playTime;
            Material.SetFloat("_Phase", 0);
            EffectObj.SetActive(true);
            StartCoroutine("PlayEffect");
        }
        public IEnumerator PlayEffect() {
            float totalTime = 0;
            float phase = 0;
            while (phase < 0.98) {
                totalTime += Time.deltaTime;
                phase = totalTime / PlayTime;
                Material.SetFloat("_Phase", phase);
                yield return null;
            }
            Destroy(EffectObj);
        }
    }
    public EffectSystem() {
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        switch (areaOfEffect) {
            case SingleTarget: ApplyTagsEffectSingle(); break;
            case CircleArea aoe: ApplyTagsEffectRadius(tags, origin, direction, aoe); break;
            case ConeArea aoe: ApplyTagsEffectCone(tags, origin, direction, aoe); break;
            case PathArea aoe: ApplyTagsEffectPath(tags, origin, direction, aoe); break;
        }
    }
    void ApplyTagsEffectSingle() {
        Debug.Log("ApplyTagsEffectSingle");
    }
    void ApplyTagsEffectPath(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, PathArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateQuadMeshForUnit(origin, areaOfEffect.Width, areaOfEffect.Length);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectRadius(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, CircleArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, 360, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectCone(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, ConeArea areaOfEffect) {
        Debug.Log("ApplyTagsEffectCone");
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, areaOfEffect.Angle, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("GetEffectColor");
        var color = new Color();
        Debug.Log($"GetEffectColor length {tags.Count()}");
        if (_colorMapping == null) {
            foreach (var tag in tags) {
                Debug.Log("GetEffectColor tag");
                if (_colorMapping.ContainsKey(tag.Item1)) {
                    Debug.Log("GetEffectColor mapping found");
                    var mappedColor = _colorMapping[tag.Item1];
                    // TODO: scale color by amount
                    color += mappedColor;
                }
            }
        }
        Debug.Log("GetEffectColor Finished");
        return color;
    }
    public Mesh CreateArcMeshForUnit(Transform unit, float arc, float length, int numberOfVerticesInArc = 100) {
        return CreateArcMesh(unit.forward, arc, length, numberOfVerticesInArc, Vector3.up);
    }
    public Mesh CreateQuadMeshForUnit(Transform unit, float width, float length) {
        return CreateQuadMesh(unit.forward, width, length, Vector3.up);
    }
    void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh, Material material) {
        GameObject effectObj = new();
        effectObj.SetActive(false);
        effectObj.transform.position = originUnit.position;
        effectObj.transform.rotation = direction;
        var meshRenderer = effectObj.AddComponent<MeshRenderer>();
        meshRenderer.sharedMaterial = material;
        meshRenderer.shadowCastingMode = 0;
        meshRenderer.receiveShadows = false;
        var meshFilter = effectObj.AddComponent<MeshFilter>();
        meshFilter.mesh = mesh;
        effectObj.AddComponent<EffectRunner>();
        var effectRunner = effectObj.GetComponent<EffectRunner>();
        effectRunner.Run(effectObj, material, 1f);
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        var origin = Vector3.zero;
        Mesh mesh = new();
        var n = numberOfVerticesInArc + 1;
        var arcStep = arc / (n - 2);
        var currentDegrees = -arc / 2;
        var vertices = new Vector3[n];
        var uv = new Vector2[n];
        vertices[0] = origin;
        uv[0] = origin;
        for (var i = 1; i < n; i++) {
            vertices[i] = Quaternion.AngleAxis(currentDegrees, rotationAxis) * direction * length;
            uv[i] = new Vector2(0, 1);
            //Debug.Log($"Current Degrees: {currentDegrees} -> {vertices[i]}");
            currentDegrees += arcStep;
        }
        mesh.vertices = vertices;
        mesh.uv = uv;
        var tris = new int[(n - 2) * 3];
        for (var i = 0; i < n - 2; i++) {
            tris[i * 3] = 0;
            tris[i * 3 + 1] = i + 1;
            tris[i * 3 + 2] = i + 2;
        }
        mesh.triangles = tris;
        var normals = new Vector3[n];
        for (var i = 0; i < n; i++) {
            normals[i] = rotationAxis;
        }
        mesh.normals = normals;
        return mesh;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Mesh mesh = new();
        var origin = Vector3.zero;
        // TODO: how to calculate local rotation? direction
        var vertices = new Vector3[4]
        {
            new Vector3(-width/2, 0, 0) + origin,
            new Vector3(width/2, 0, 0) + origin,
            new Vector3(-width/2, 0, length) + origin,
            new Vector3(width/2, 0, length) + origin
        };
        mesh.vertices = vertices;
        var tris = new int[6]
        {
            // lower left triangle
            0, 2, 1,
            // upper right triangle
            2, 3, 1
        };
        mesh.triangles = tris;
        var normals = new Vector3[4]
        {
            rotationAxis,
            rotationAxis,
            rotationAxis,
            rotationAxis
        };
        mesh.normals = normals;
        var uv = new Vector2[4]
        {
            new Vector2(0, 0),
            new Vector2(1, 0),
            new Vector2(0, 1),
            new Vector2(1, 1)
        };
        mesh.uv = uv;
        return mesh;
    }
}

Replacement in Assets/Scripts/PawnResources/Resource.cs at line 1 [4.6208]

B:BD[4.6208] → [4.6209:6224]

B:BD[4.6251] → [5.10616:10651]

B:BD[5.10651] → [6.5521:5546]

∅:D[6.5546] → [4.6251:6308]

∅:D[5.10671] → [4.6251:6308]

B:BD[4.6251] → [4.6251:6308]

B:BD[4.6308] → [7.9983:10071]

∅:D[7.10071] → [8.509:611]

B:BD[8.509] → [8.509:611]

∅:D[8.611] → [4.6308:6328]

B:BD[4.6308] → [4.6308:6328]

B:BD[4.6328] → [8.612:746]

∅:D[9.425] → [4.6410:6417]

∅:D[8.746] → [4.6410:6417]

∅:D[10.3339] → [4.6410:6417]

∅:D[5.10774] → [4.6410:6417]

B:BD[4.6410] → [4.6410:6417]

B:BD[4.6417] → [11.1615:1717]

∅:D[9.588] → [4.6564:6566]

∅:D[11.1717] → [4.6564:6566]

∅:D[5.10880] → [4.6564:6566]

∅:D[12.12286] → [4.6564:6566]

B:BD[4.6564] → [4.6564:6566]

B:BD[4.6566] → [5.10881:10954]

∅:D[5.10954] → [4.6679:6681]

B:BD[4.6679] → [4.6679:6681]

B:BD[4.6681] → [6.5547:5618]

∅:D[6.5618] → [4.6740:6742]

B:BD[4.6740] → [4.6740:6742]

B:BD[4.6742] → [5.10955:11003]

B:BD[5.11003] → [6.5619:5661]

∅:D[6.5661] → [5.11045:11186]

B:BD[5.11045] → [5.11045:11186]

B:BD[5.11186] → [6.5662:5832]

∅:D[11.1776] → [5.11402:11413]

∅:D[6.5832] → [5.11402:11413]

B:BD[5.11402] → [5.11402:11413]

B:BD[4.7152] → [4.7152:7154]

B:BD[4.7154] → [5.11830:11877]

B:BD[5.11877] → [6.5833:5874]

∅:D[6.5874] → [5.11918:12040]

B:BD[5.11918] → [5.11918:12040]

B:BD[5.12040] → [6.5875:6043]

∅:D[11.1892] → [5.12253:12264]

∅:D[6.6043] → [5.12253:12264]

B:BD[5.12253] → [5.12253:12264]

B:BD[11.1959] → [11.1959:1961]

B:BD[11.1961] → [6.6044:6168]

∅:D[13.2439] → [11.2080:2123]

∅:D[6.6168] → [11.2080:2123]

B:BD[11.2080] → [11.2080:2123]

B:BD[11.2123] → [6.6169:6290]

∅:D[6.6290] → [11.2202:2204]

B:BD[4.7542] → [11.2202:2204]

B:BD[11.2204] → [6.6291:6345]

∅:D[6.6345] → [4.7553:7555]

B:BD[4.7553] → [4.7553:7555]

B:BD[4.7555] → [6.6346:6514]

∅:D[6.6514] → [5.12939:12941]

B:BD[5.12939] → [5.12939:12941]

B:BD[5.12941] → [6.6515:6679]

B:BD[6.6679] → [14.76326:76602]

∅:D[11.2709] → [4.7799:7812]

∅:D[6.6781] → [4.7799:7812]

∅:D[5.13115] → [4.7799:7812]

∅:D[14.76602] → [4.7799:7812]

B:BD[4.7799] → [4.7799:7812]

B:BD[4.7812] → [6.6782:6885]

∅:D[8.850] → [11.2854:2909]

∅:D[6.6885] → [11.2854:2909]

∅:D[7.10246] → [11.2854:2909]

B:BD[11.2854] → [11.2854:2909]

B:BD[11.2909] → [13.2440:2519]

∅:D[13.2519] → [11.3004:3160]

B:BD[11.3004] → [11.3004:3160]

B:BD[11.3160] → [6.6886:6955]

∅:D[6.6955] → [11.3277:3500]

∅:D[15.15028] → [11.3277:3500]

B:BD[11.3277] → [11.3277:3500]

B:BD[11.3694] → [11.3694:3696]

B:BD[11.3696] → [6.6956:7055]

∅:D[6.7055] → [11.4000:4017]

B:BD[11.4000] → [11.4000:4017]

B:BD[11.4017] → [6.7056:7460]

∅:D[6.7460] → [11.4650:4667]

∅:D[15.15087] → [11.4650:4667]

B:BD[11.4650] → [11.4650:4667]

B:BD[11.4667] → [6.7461:7903]

∅:D[6.7903] → [11.4867:4882]

∅:D[15.15133] → [11.4867:4882]

B:BD[11.4867] → [11.4867:4882]

∅:D[11.4882] → [4.8305:8316]

∅:D[6.7908] → [4.8305:8316]

∅:D[5.13335] → [4.8305:8316]

B:BD[4.8305] → [4.8305:8316]

∅:D[11.4885] → [12.12485:12492]

B:BD[4.8710] → [12.12485:12492]

∅:D[12.12492] → [4.8710:8711]

B:BD[4.8710] → [4.8710:8711]

using System;
using System.Collections.Generic;
using System.Threading;
using UnityEngine;
namespace TagFighter.Resources
{
    public interface IAccessibleResource<TUnitType> where TUnitType : IUnitType
    {
        public Unit<TUnitType> GetCapacity();
        public Unit<TUnitType> GetCurrent();
    }
    [Serializable]
    public class Resource<TUnitType> : MonoBehaviour, IWatchableResource, IAccessibleResource<TUnitType> where TUnitType : IUnitType
    {
        [SerializeField] Stat<Current> _current;
        [SerializeField] Stat<Capacity> _capacity;
        readonly Unit<TUnitType> _minimumCapacity = (Unit<TUnitType>)0;
        public ResourceChangeArgs Status => (ResourceChangeArgs)this;
        public Unit<TUnitType> GetCapacity() {
            var value = _capacity.Total;
            if (value < _minimumCapacity) {
                value = _minimumCapacity;
            }
            return value;
        }
        public void AddCapacityModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _capacity, cancelToken);
        }
        public Unit<TUnitType> GetCurrent() {
            var value = _current.Total;
            value = Unit<TUnitType>.Clamp(value, _minimumCapacity, GetCapacity());
            return value;
        }
        public void AddCurrentModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _current, cancelToken);
        }
        void AddModifier<TStatType>(StatModifier<TUnitType> modifier, Stat<TStatType> stat, CancellationToken cancelToken)
            where TStatType : IStatType {
            cancelToken.Register(() => {
                OnResourceChanged((ResourceChangeArgs)this);
            });
            stat.AddModifier(modifier, cancelToken);
            Debug.Log($"AddModifier {transform.name}.{GetType().Name}.{typeof(TStatType).Name}");
            OnResourceChanged((ResourceChangeArgs)this);
        }
        public event EventHandler<ResourceChangeArgs> ResourceChanged;
        public static explicit operator ResourceChangeArgs(Resource<TUnitType> resource) {
            return new((int)resource.GetCurrent(), (int)resource._current.Base, (int)resource._current.Modified,
                       (int)resource.GetCapacity(), (int)resource._capacity.Base, (int)resource._capacity.Modified,
                       resource.transform);
        }
        void OnResourceChanged(ResourceChangeArgs e) {
            ResourceChanged?.Invoke(this, e);
        }
        public interface IStatType { }
        class Current : IStatType { }
        class Capacity : IStatType { }
        [Serializable]
        public class Stat<TStatType> where TStatType : IStatType
        {
            [SerializeField] Unit<TUnitType> _base;
            LinkedList<StatModifier<TUnitType>> _modifiers = new();
            public Unit<TUnitType> Base {
                get {
                    return _base;
                }
                private set {
                    _base = value;
                }
            }
            public Unit<TUnitType> Modified {
                get;
                private set;
            }
            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);
                }
            }
            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;
                });
            }
        }
    }
}

[4.6208]

using System;
using System.Collections.Generic;
using System.Threading;
using CareBoo.Serially;
using UnityEngine;
namespace TagFighter.Resources
{
    public interface IAccessibleResource<TUnitType> where TUnitType : IUnitType
    {
        public Unit<TUnitType> GetCapacity();
        public Unit<TUnitType> GetCurrent();
    }
    [Serializable]
    public class Resource<TUnitType> : MonoBehaviour, IWatchableResource, IAccessibleResource<TUnitType> where TUnitType : IUnitType
    {
        [SerializeField] Stat<Current> _current;
        [SerializeField] Stat<Capacity> _capacity;
        readonly Unit<TUnitType> _minimumCapacity = (Unit<TUnitType>)0;
        public ResourceChangeArgs Status => (ResourceChangeArgs)this;
        public Unit<TUnitType> GetCapacity() {
            var value = _capacity.Total;
            if (value < _minimumCapacity) {
                value = _minimumCapacity;
            }
            return value;
        }
        public void AddCapacityModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _capacity, cancelToken);
        }
        public Unit<TUnitType> GetCurrent() {
            var value = _current.Total;
            value = Unit<TUnitType>.Clamp(value, _minimumCapacity, GetCapacity());
            return value;
        }
        public void AddCurrentModifier(StatModifier<TUnitType> modifier, CancellationToken cancelToken) {
            AddModifier(modifier, _current, cancelToken);
        }
        void AddModifier<TStatType>(StatModifier<TUnitType> modifier, Stat<TStatType> stat, CancellationToken cancelToken)
            where TStatType : IStatType {
            cancelToken.Register(() => {
                OnResourceChanged((ResourceChangeArgs)this);
            });
            stat.AddModifier(modifier, cancelToken);
            Debug.Log($"AddModifier {transform.name}.{GetType().Name}.{typeof(TStatType).Name}");
            OnResourceChanged((ResourceChangeArgs)this);
        }
        public event EventHandler<ResourceChangeArgs> ResourceChanged;
        public static explicit operator ResourceChangeArgs(Resource<TUnitType> resource) {
            return new((int)resource.GetCurrent(), (int)resource._current.Base, (int)resource._current.Modified,
                       (int)resource.GetCapacity(), (int)resource._capacity.Base, (int)resource._capacity.Modified,
                       resource.transform);
        }
        void OnResourceChanged(ResourceChangeArgs e) {
            ResourceChanged?.Invoke(this, e);
        }
        public interface IStatType { }
        class Current : IStatType { }
        class Capacity : IStatType { }
        [Serializable]
        public class Stat<TStatType> where TStatType : IStatType
        {
            [SerializeField] Unit<TUnitType> _base;
            LinkedList<StatModifier<TUnitType>> _modifiers = new();
            public Unit<TUnitType> Base {
                get {
                    return _base;
                }
                private set {
                    _base = value;
                }
            }
            public Unit<TUnitType> Modified {
                get;
                private set;
            }
            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);
                }
            }
            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;
                });
            }
        }
    }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/SwordKnowledge.cs at line 1 [16.7516]

B:BD[16.7516] → [17.28300:28585]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("F18D2C2B-4AA0-45EA-8137-70D85F067FFA")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class SwordKnowledge : Resource<SwordKP> { }
}

[16.7516]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("F18D2C2B-4AA0-45EA-8137-70D85F067FFA")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class SwordKnowledge : Resource<SwordKP> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/ShieldKnowledge.cs at line 1 [16.7992]

B:BD[16.7992] → [17.28588:28875]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("18751303-04F3-47B4-B66D-9E734E55F0E8")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class ShieldKnowledge : Resource<ShieldKP> { }
}

[16.7992]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("18751303-04F3-47B4-B66D-9E734E55F0E8")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class ShieldKnowledge : Resource<ShieldKP> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/RedTag.cs at line 1 [18.533]

B:BD[18.533] → [17.28878:29158]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("7F412C19-18FE-476F-92E4-469FFAD0C5D4")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class RedTag : Resource<RedTagUnit> { }
}

[18.533]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("7F412C19-18FE-476F-92E4-469FFAD0C5D4")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class RedTag : Resource<RedTagUnit> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/RecklessFormKnowledge.cs at line 1 [19.20652]

B:BD[19.20652] → [17.29161:29460]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("4B8E4C4F-03D6-4102-9936-AC66DD899EE2")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class RecklessFormKnowledge : Resource<RecklessFormKP> { }
}

[19.20652]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("4B8E4C4F-03D6-4102-9936-AC66DD899EE2")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class RecklessFormKnowledge : Resource<RecklessFormKP> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/Range.cs at line 1 [20.285]

B:BD[20.285] → [17.29463:29934]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("CF53C617-F396-4C4F-9317-F935188D525C")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class Range : Resource<Centimeter> { }
    public static class CentimeterExtensions
    {
        public static float ToMeter(this Unit<Centimeter> source) {
            return source.AsPrimitive() * 0.01f;
        }
    }
}

[20.285]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("CF53C617-F396-4C4F-9317-F935188D525C")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class Range : Resource<Centimeter> { }
    public static class CentimeterExtensions
    {
        public static float ToMeter(this Unit<Centimeter> source) {
            return source.AsPrimitive() * 0.01f;
        }
    }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/Pain.cs at line 1 [18.985]

B:BD[18.985] → [17.29937:30213]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("30A0DDC8-3FCF-496A-B578-81DBF333C7EC")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class Pain : Resource<PainUnit> { }
}

[18.985]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("30A0DDC8-3FCF-496A-B578-81DBF333C7EC")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class Pain : Resource<PainUnit> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/GreenTag.cs at line 1 [18.1435]

B:BD[18.1435] → [17.30216:30500]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("DA13F1C1-4359-4EB9-B969-7DB50AFE6423")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class GreenTag : Resource<GreenTagUnit> { }
}

[18.1435]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("DA13F1C1-4359-4EB9-B969-7DB50AFE6423")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class GreenTag : Resource<GreenTagUnit> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/Fatigue.cs at line 1 [18.1896]

B:BD[18.1896] → [17.30503:30785]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("59A26139-CA50-4E6F-8AC0-27DFB70CCB8B")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class Fatigue : Resource<FatigueUnit> { }
}

[18.1896]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("59A26139-CA50-4E6F-8AC0-27DFB70CCB8B")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class Fatigue : Resource<FatigueUnit> { }
}

Replacement in Assets/Scripts/PawnResources/PawnAttributes/BlueTag.cs at line 1 [18.2354]

B:BD[18.2354] → [17.30788:31070]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("AECC1739-A0DF-4013-B430-22D2EB13F0FF")]
    [Serializable]
    [ProvideSourceInfo()]
    public sealed class BlueTag : Resource<BlueTagUnit> { }
}

[18.2354]

using System;
using System.Runtime.InteropServices;
using CareBoo.Serially;
namespace TagFighter.Resources
{
    [Guid("AECC1739-A0DF-4013-B430-22D2EB13F0FF")]
    [Serializable]
    [ProvideSourceInfo]
    public sealed class BlueTag : Resource<BlueTagUnit> { }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/ResourceAccessors/ResourceTypeAccessors.cs at line 1 [21.554]

B:BD[21.554] → [21.555:570]

B:BD[21.597] → [21.597:632]

B:BD[21.632] → [8.1104:1192]

∅:D[8.1192] → [21.632:681]

B:BD[21.632] → [21.632:681]

∅:D[22.1512] → [21.681:683]

B:BD[21.681] → [21.681:683]

B:BD[21.685] → [21.685:718]

B:BD[21.718] → [8.1193:1231]

∅:D[8.1231] → [18.6527:6612]

B:BD[18.6527] → [18.6527:6612]

B:BD[18.6612] → [8.1232:1310]

∅:D[8.1310] → [18.6612:6621]

B:BD[18.6612] → [18.6612:6621]

∅:D[18.6621] → [21.718:769]

B:BD[21.718] → [21.718:769]

B:BD[21.769] → [5.13414:13603]

∅:D[22.1771] → [21.999:1006]

∅:D[23.1800] → [21.999:1006]

∅:D[10.3666] → [21.999:1006]

∅:D[5.13603] → [21.999:1006]

B:BD[21.999] → [21.999:1006]

B:BD[21.1006] → [19.469468:469470]

B:BD[19.469470] → [24.315403:315553]

∅:D[8.1409] → [21.1087:1130]

∅:D[18.6729] → [21.1087:1130]

∅:D[24.315553] → [21.1087:1130]

B:BD[21.1087] → [21.1087:1130]

B:BD[21.1130] → [10.3667:3700]

∅:D[10.3700] → [21.1159:1166]

B:BD[21.1159] → [21.1159:1166]

B:BD[21.1166] → [5.13604:13790]

∅:D[23.2038] → [22.2004:2017]

∅:D[5.13790] → [22.2004:2017]

B:BD[22.2004] → [22.2004:2017]

B:BD[22.2017] → [5.13791:13987]

∅:D[5.13987] → [22.2261:2272]

B:BD[22.2261] → [22.2261:2272]

∅:D[22.2272] → [21.1553:1555]

B:BD[21.1553] → [21.1553:1555]

B:BD[21.1555] → [18.6730:6879]

B:BD[18.6879] → [24.315554:315736]

∅:D[18.6879] → [21.1555:1630]

∅:D[24.315736] → [21.1555:1630]

B:BD[21.1555] → [21.1555:1630]

B:BD[21.1630] → [8.1410:1412]

B:BD[8.1412] → [24.315737:315961]

∅:D[24.315961] → [8.1581:1592]

B:BD[8.1581] → [8.1581:1592]

B:BD[8.1592] → [24.315962:316279]

∅:D[8.1592] → [21.1630:1683]

∅:D[24.316279] → [21.1630:1683]

B:BD[21.1630] → [21.1630:1683]

B:BD[21.1683] → [25.413:959]

B:BD[25.959] → [20.53617:53723]

B:BD[20.53723] → [19.469471:469613]

B:BD[19.469613] → [16.95949:96194]

∅:D[25.959] → [21.2199:2209]

∅:D[20.53723] → [21.2199:2209]

∅:D[16.96194] → [21.2199:2209]

∅:D[19.469613] → [21.2199:2209]

B:BD[21.2199] → [21.2199:2209]

using System;
using System.Collections.Generic;
using System.Linq;
using TagFighter.Effects.ResourceLocationAccessors.PawnProperties;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public interface IResourceGetter
    {
        public IWatchableResource GetWatchableResource(Transform transform);
        public int GetStat(Transform transform, IPawnResourceProperty stat);
    }
    public interface IResourceTypeAccessor
    {
        public IEnumerable<double> Get(EffectInput data, IResourceLocationGet accessor);
        public void Set(EffectInput data, IResourceLocationSet accessor, IEnumerable<int> value);
    }
    public class ResourceTypeAccessor<TResource, TUnit> : IResourceTypeAccessor, IResourceGetter, IEquatable<ResourceTypeAccessor<TResource, TUnit>>
        where TResource : Resource<TUnit>
        where TUnit : IUnitType
    {
        public IEnumerable<double> Get(EffectInput data, IResourceLocationGet accessor) {
            return accessor.Get<TResource, TUnit>(data).Select(resource => (double)resource);
        }
        public void Set(EffectInput data, IResourceLocationSet accessor, IEnumerable<int> values) {
            accessor.Set<TResource, TUnit>(data, values.Select(value => (Unit<TUnit>)value));
        }
        public IWatchableResource GetWatchableResource(Transform transform) {
            return transform.GetComponent<TResource>();
        }
        public int GetStat(Transform transform, IPawnResourceProperty stat) {
            return (int)stat.Get<TResource, TUnit>(transform.GetComponent<TResource>());
        }
        public override string ToString() => $"{typeof(TResource).Name}";
        public bool Equals(ResourceTypeAccessor<TResource, TUnit> other) {
            if ((other == null) || !GetType().Equals(other.GetType())) {
                return false;
            }
            return true;
        }
        public override bool Equals(object other) {
            if ((other == null) || !GetType().Equals(other.GetType())) {
                return false;
            }
            return true;
        }
        public override int GetHashCode() {
            return GetType().GetHashCode();
        }
    }
    namespace ResourceTypeAccessors
    {
        [Serializable] public sealed class Pain : ResourceTypeAccessor<Resources.Pain, PainUnit> { }
        [Serializable] public sealed class Fatigue : ResourceTypeAccessor<Resources.Fatigue, FatigueUnit> { }
        [Serializable] public sealed class BlueTag : ResourceTypeAccessor<Resources.BlueTag, BlueTagUnit> { }
        [Serializable] public sealed class RedTag : ResourceTypeAccessor<Resources.RedTag, RedTagUnit> { }
        [Serializable] public sealed class GreenTag : ResourceTypeAccessor<Resources.GreenTag, GreenTagUnit> { }
        [Serializable] public sealed class Range : ResourceTypeAccessor<Resources.Range, Centimeter> { }
        [Serializable] public sealed class RecklessFormKnowledge : ResourceTypeAccessor<Resources.RecklessFormKnowledge, RecklessFormKP> { }
        [Serializable] public sealed class SwordKnowledge : ResourceTypeAccessor<Resources.SwordKnowledge, SwordKP> { }
        [Serializable] public sealed class ShieldKnowledge : ResourceTypeAccessor<Resources.ShieldKnowledge, ShieldKP> { }
    }
}

[21.554]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Effects.ResourceLocationAccessors.PawnProperties;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public interface IResourceGetter
    {
        public IWatchableResource GetWatchableResource(Transform transform);
        public int GetStat(Transform transform, IPawnResourceProperty stat);
    }
    public interface IResourceTypeAccessor
    {
        public IEnumerable<double> Get(EffectInput data, IResourceLocationGet accessor);
        public void Set(EffectInput data, IResourceLocationSet accessor, IEnumerable<int> value);
    }
    public class ResourceTypeAccessor<TResource, TUnit> : IResourceTypeAccessor, IResourceGetter, IEquatable<ResourceTypeAccessor<TResource, TUnit>>
        where TResource : Resource<TUnit>
        where TUnit : IUnitType
    {
        public IEnumerable<double> Get(EffectInput data, IResourceLocationGet accessor) {
            return accessor.Get<TResource, TUnit>(data).Select(resource => (double)resource);
        }
        public void Set(EffectInput data, IResourceLocationSet accessor, IEnumerable<int> values) {
            accessor.Set<TResource, TUnit>(data, values.Select(value => (Unit<TUnit>)value));
        }
        public IWatchableResource GetWatchableResource(Transform transform) {
            return transform.GetComponent<TResource>();
        }
        public int GetStat(Transform transform, IPawnResourceProperty stat) {
            return (int)stat.Get<TResource, TUnit>(transform.GetComponent<TResource>());
        }
        public override string ToString() => $"{typeof(TResource).Name}";
        public bool Equals(ResourceTypeAccessor<TResource, TUnit> other) {
            if ((other == null) || !GetType().Equals(other.GetType())) {
                return false;
            }
            return true;
        }
        public override bool Equals(object other) {
            if ((other == null) || !GetType().Equals(other.GetType())) {
                return false;
            }
            return true;
        }
        public override int GetHashCode() {
            return GetType().GetHashCode();
        }
    }
    namespace ResourceTypeAccessors
    {
        [ProvideSourceInfo][Serializable] public sealed class Pain : ResourceTypeAccessor<Resources.Pain, PainUnit> { }
        [ProvideSourceInfo][Serializable] public sealed class Fatigue : ResourceTypeAccessor<Resources.Fatigue, FatigueUnit> { }
        [ProvideSourceInfo][Serializable] public sealed class BlueTag : ResourceTypeAccessor<Resources.BlueTag, BlueTagUnit> { }
        [ProvideSourceInfo][Serializable] public sealed class RedTag : ResourceTypeAccessor<Resources.RedTag, RedTagUnit> { }
        [ProvideSourceInfo][Serializable] public sealed class GreenTag : ResourceTypeAccessor<Resources.GreenTag, GreenTagUnit> { }
        [ProvideSourceInfo][Serializable] public sealed class Range : ResourceTypeAccessor<Resources.Range, Centimeter> { }
        [ProvideSourceInfo][Serializable] public sealed class RecklessFormKnowledge : ResourceTypeAccessor<Resources.RecklessFormKnowledge, RecklessFormKP> { }
        [ProvideSourceInfo][Serializable] public sealed class SwordKnowledge : ResourceTypeAccessor<Resources.SwordKnowledge, SwordKP> { }
        [ProvideSourceInfo][Serializable] public sealed class ShieldKnowledge : ResourceTypeAccessor<Resources.ShieldKnowledge, ShieldKP> { }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/ResourceAccessors/ResourceOperators.cs at line 1 [22.297]

B:BD[22.297] → [22.298:313]

B:BD[22.340] → [22.340:375]

B:BD[22.375] → [10.3956:4005]

∅:D[10.4005] → [22.395:477]

B:BD[22.395] → [22.395:477]

B:BD[22.477] → [10.4006:4507]

∅:D[10.4507] → [22.526:535]

B:BD[22.526] → [22.526:535]

B:BD[22.535] → [10.4508:4533]

∅:D[10.4533] → [22.605:612]

B:BD[22.605] → [22.605:612]

B:BD[22.612] → [10.4534:5875]

∅:D[10.5875] → [22.728:730]

B:BD[22.728] → [22.728:730]

B:BD[22.730] → [10.5876:6216]

∅:D[10.6216] → [22.921:931]

B:BD[22.921] → [22.921:931]

using System;
using System.Collections.Generic;
using System.Linq;
using TagFighter.Resources;
namespace TagFighter.Effects
{
    public interface IResourceOperator
    {
        public double Operate(params double[] values) => OperateEnum(values);
        public Unit<TUnit> Operate<TUnit>(params Unit<TUnit>[] values) where TUnit : IUnitType => OperateEnum(values);
        public Unit<TUnit> OperateEnum<TUnit>(IEnumerable<Unit<TUnit>> values) where TUnit : IUnitType => (Unit<TUnit>)OperateEnum(values.Select(value => value.AsPrimitive()));
        public double OperateEnum(IEnumerable<double> values);
        public int OperateEnum(IEnumerable<int> values);
    }
    namespace Operators
    {
        [Serializable]
        public class Sum : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> a) => a.Sum();
            public int OperateEnum(IEnumerable<int> a) => a.Sum();
            public override string ToString() => nameof(Sum);
        }
        [Serializable]
        public class Multiply : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Aggregate(1d, (acc, val) => acc * val);
            public int OperateEnum(IEnumerable<int> values) => values.Aggregate(1, (acc, val) => acc * val);
            public override string ToString() => nameof(Multiply);
        }
        [Serializable]
        public class Min : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Min();
            public int OperateEnum(IEnumerable<int> values) => values.Min();
            public override string ToString() => nameof(Min);
        }
        [Serializable]
        public class Max : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Max();
            public int OperateEnum(IEnumerable<int> values) => values.Max();
            public override string ToString() => nameof(Max);
        }
        [Serializable]
        public class Average : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Average();
            public int OperateEnum(IEnumerable<int> values) => (int)values.Average();
            public override string ToString() => nameof(Average);
        }
    }
}

[22.297]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
namespace TagFighter.Effects
{
    public interface IResourceOperator
    {
        public double Operate(params double[] values) => OperateEnum(values);
        public Unit<TUnit> Operate<TUnit>(params Unit<TUnit>[] values) where TUnit : IUnitType => OperateEnum(values);
        public Unit<TUnit> OperateEnum<TUnit>(IEnumerable<Unit<TUnit>> values) where TUnit : IUnitType => (Unit<TUnit>)OperateEnum(values.Select(value => value.AsPrimitive()));
        public double OperateEnum(IEnumerable<double> values);
        public int OperateEnum(IEnumerable<int> values);
    }
    namespace Operators
    {
        [ProvideSourceInfo]
        [Serializable]
        public class Sum : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> a) => a.Sum();
            public int OperateEnum(IEnumerable<int> a) => a.Sum();
            public override string ToString() => nameof(Sum);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Multiply : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Aggregate(1d, (acc, val) => acc * val);
            public int OperateEnum(IEnumerable<int> values) => values.Aggregate(1, (acc, val) => acc * val);
            public override string ToString() => nameof(Multiply);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Min : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Min();
            public int OperateEnum(IEnumerable<int> values) => values.Min();
            public override string ToString() => nameof(Min);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Max : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Max();
            public int OperateEnum(IEnumerable<int> values) => values.Max();
            public override string ToString() => nameof(Max);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Average : IResourceOperator
        {
            public double OperateEnum(IEnumerable<double> values) => values.Average();
            public int OperateEnum(IEnumerable<int> values) => (int)values.Average();
            public override string ToString() => nameof(Average);
        }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/ResourceAccessors/PawnResourceAccessors.cs at line 1 [21.2560]

B:BD[21.2560] → [21.2561:2631]

B:BD[21.2631] → [10.6219:6244]

∅:D[10.6244] → [21.2631:2684]

B:BD[21.2631] → [21.2631:2684]

B:BD[21.2684] → [23.2679:2735]

∅:D[23.2735] → [21.2714:2717]

B:BD[21.2714] → [21.2714:2717]

B:BD[21.2717] → [23.2736:2766]

∅:D[23.2766] → [21.2787:2794]

∅:D[10.6265] → [21.2787:2794]

B:BD[21.2787] → [21.2787:2794]

B:BD[21.2794] → [10.6266:6399]

B:BD[10.6399] → [8.1599:1686]

∅:D[8.1686] → [5.14303:14407]

B:BD[10.6475] → [5.14303:14407]

∅:D[5.14407] → [10.6561:6637]

B:BD[10.6561] → [10.6561:6637]

∅:D[10.6637] → [22.2546:2559]

B:BD[22.2546] → [22.2546:2559]

B:BD[22.2559] → [10.6638:6801]

B:BD[10.6801] → [8.1687:1799]

∅:D[8.1799] → [5.14509:14746]

B:BD[5.14509] → [5.14509:14746]

∅:D[5.14746] → [10.7087:7167]

B:BD[10.7087] → [10.7087:7167]

B:BD[10.7167] → [7.14683:14685]

∅:D[7.14685] → [10.7169:7333]

∅:D[5.14757] → [10.7169:7333]

B:BD[10.7169] → [10.7169:7333]

B:BD[10.7333] → [8.1800:1913]

∅:D[8.1913] → [5.14860:15098]

B:BD[5.14860] → [5.14860:15098]

∅:D[5.15098] → [10.7621:7691]

B:BD[10.7621] → [10.7621:7691]

∅:D[22.3138] → [21.3320:3331]

∅:D[10.7691] → [21.3320:3331]

B:BD[21.3320] → [21.3320:3331]

B:BD[10.8265] → [23.2767:2774]

∅:D[23.2774] → [10.8265:8267]

B:BD[10.8265] → [10.8265:8267]

B:BD[10.8267] → [23.2775:2832]

∅:D[23.2832] → [10.8952:8954]

B:BD[22.3373] → [10.8952:8954]

B:BD[10.8954] → [23.2833:2976]

B:BD[23.2976] → [15.18941:18993]

∅:D[15.18993] → [5.15099:15184]

B:BD[23.3021] → [5.15099:15184]

∅:D[5.15184] → [23.3144:3238]

B:BD[23.3144] → [23.3144:3238]

B:BD[23.3238] → [5.15185:15408]

∅:D[22.3373] → [21.3713:3728]

∅:D[23.3451] → [21.3713:3728]

∅:D[10.9038] → [21.3713:3728]

∅:D[5.15408] → [21.3713:3728]

B:BD[21.3713] → [21.3713:3728]

B:BD[21.3728] → [23.3452:3534]

∅:D[23.3534] → [21.3728:3739]

B:BD[21.3728] → [21.3728:3739]

B:BD[21.3739] → [23.3535:3542]

∅:D[23.3542] → [21.3739:3741]

B:BD[21.3739] → [21.3739:3741]

B:BD[21.3741] → [23.3543:3600]

B:BD[23.3600] → [5.15409:15411]

∅:D[5.15411] → [23.3610:3684]

B:BD[23.3610] → [23.3610:3684]

∅:D[23.3684] → [10.9062:9073]

B:BD[10.9062] → [10.9062:9073]

B:BD[10.9073] → [23.3685:3743]

B:BD[23.3743] → [15.18994:19046]

∅:D[15.19046] → [5.15412:15510]

B:BD[23.3788] → [5.15412:15510]

∅:D[5.15510] → [23.3924:4133]

B:BD[23.3924] → [23.3924:4133]

B:BD[23.4133] → [5.15511:15819]

∅:D[23.4425] → [10.10277:10296]

∅:D[5.15819] → [10.10277:10296]

B:BD[10.10277] → [10.10277:10296]

B:BD[10.10382] → [10.10382:10397]

B:BD[10.10397] → [23.4426:4508]

∅:D[23.4508] → [10.10397:10408]

B:BD[10.10397] → [10.10397:10408]

∅:D[10.10408] → [21.3803:3811]

B:BD[21.3803] → [21.3803:3811]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects.ResourceLocationAccessors
{
    namespace PawnProperties
    {
        public interface IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType;
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType;
        }
        [Serializable]
        public class Current : IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType => resource.GetCurrent();
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType => data.StatAccessor.AddCurrentModifier(resource, value);
            public override string ToString() => nameof(Current);
        }
        [Serializable]
        public class Capacity : IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType => resource.GetCapacity();
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType => data.StatAccessor.AddCapacityModifier(resource, value);
            public override string ToString() => nameof(Capacity);
        }
    }
    namespace Get
    {
        using PawnProperties;
        [Serializable]
        public class Pawn : IResourceLocationGet
        {
            [SerializeReference, ShowSerializeReference]
            public IPawnResourceProperty Property;
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                return data.Affected.Select(transform => transform.GetComponent<TResource>())
                                    .Select(resource => resource ? Property.Get<TResource, TUnit>(resource) : (Unit<TUnit>)0);
            }
            public override string ToString() => $"{nameof(Pawn)}.{Property}";
        }
    }
    namespace Set
    {
        using PawnProperties;
        [Serializable]
        public class Pawn : IResourceLocationSet
        {
            [SerializeReference, ShowSerializeReference]
            public IPawnResourceProperty Property;
            public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                var repeatedValues = Enumerable.Repeat(values.ToList(), int.MaxValue).SelectMany(value => value);
                foreach (var tuple in data.Affected.Zip(repeatedValues, (transform, value) => (resource: transform.GetComponent<TResource>(), value))
                                                   .Where(tuple => tuple.resource)) {
                    Property.Set(data, tuple.resource, tuple.value);
                }
            }
            public override string ToString() => $"{nameof(Pawn)}.{Property}";
        }
    }
}

[21.2560]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects.ResourceLocationAccessors
{
    namespace PawnProperties
    {
        public interface IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType;
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType;
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Current : IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType => resource.GetCurrent();
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType => data.StatAccessor.AddCurrentModifier(resource, value);
            public override string ToString() => nameof(Current);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Capacity : IPawnResourceProperty
        {
            public Unit<TUnit> Get<TResource, TUnit>(TResource resource)
                where TResource : IAccessibleResource<TUnit> where TUnit : IUnitType => resource.GetCapacity();
            public void Set<TResource, TUnit>(EffectInput data, TResource resource, Unit<TUnit> value)
                where TResource : Resource<TUnit> where TUnit : IUnitType => data.StatAccessor.AddCapacityModifier(resource, value);
            public override string ToString() => nameof(Capacity);
        }
    }
    namespace Get
    {
        using PawnProperties;
        [ProvideSourceInfo]
        [Serializable]
        public class Pawn : IResourceLocationGet
        {
            [SerializeReference, ShowSerializeReference]
            public IPawnResourceProperty Property;
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                return data.Affected.Select(transform => transform.GetComponent<TResource>())
                                    .Select(resource => resource ? Property.Get<TResource, TUnit>(resource) : (Unit<TUnit>)0);
            }
            public override string ToString() => $"{nameof(Pawn)}.{Property}";
        }
    }
    namespace Set
    {
        using PawnProperties;
        [ProvideSourceInfo]
        [Serializable]
        public class Pawn : IResourceLocationSet
        {
            [SerializeReference, ShowSerializeReference]
            public IPawnResourceProperty Property;
            public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                var repeatedValues = Enumerable.Repeat(values.ToList(), int.MaxValue).SelectMany(value => value);
                foreach (var tuple in data.Affected.Zip(repeatedValues, (transform, value) => (resource: transform.GetComponent<TResource>(), value))
                                                   .Where(tuple => tuple.resource)) {
                    Property.Set(data, tuple.resource, tuple.value);
                }
            }
            public override string ToString() => $"{nameof(Pawn)}.{Property}";
        }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/ResourceAccessors/ContextResourceAccessors.cs at line 1 [21.5096]

B:BD[21.5096] → [17.35601:38982]

using System;
using System.Collections.Generic;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects.ResourceLocationAccessors
{
    namespace ContextRegisters
    {
        public interface IRegisterType { }
        public class CurrentRegisterType : IRegisterType { }
        public class AddedRegisterType : IRegisterType { }
        public class RemovedRegisterType : IRegisterType { }
        public interface IContextRegister
        {
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectContext context)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType;
            public void Set<TResource, TUnit>(EffectContext context, Unit<TUnit> value)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType;
        }
        public class ContextRegister<TRegisterType> : IContextRegister where TRegisterType : IRegisterType
        {
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectContext context)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                yield return context.GetResource<TResource, TUnit, ContextRegister<TRegisterType>>();
            }
            public void Set<TResource, TUnit>(EffectContext context, Unit<TUnit> value)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                context.SetResource<TResource, TUnit, ContextRegister<TRegisterType>>(value);
            }
            public override string ToString() => typeof(TRegisterType).Name;
        }
        [Serializable] public sealed class Current : ContextRegister<CurrentRegisterType> { }
        [Serializable] public sealed class Added : ContextRegister<AddedRegisterType> { }
        [Serializable] public sealed class Removed : ContextRegister<RemovedRegisterType> { }
    }
    namespace Get
    {
        using ContextRegisters;
        [Serializable]
        public class Context : IResourceLocationGet
        {
            [SerializeReference, ShowSerializeReference]
            public IContextRegister Register;
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                return Register.Get<TResource, TUnit>(data.Context);
            }
            public override string ToString() => $"{nameof(Context)}.{Register}";
        }
    }
    namespace Set
    {
        using ContextRegisters;
        [Serializable]
        public class Context : IResourceLocationSet
        {
            [SerializeReference, ShowSerializeReference]
            public IContextRegister Register;
            [SerializeReference, ShowSerializeReference]
            public IResourceOperator SetAs;
            public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                Register.Set<TResource, TUnit>(data.Context, SetAs.OperateEnum(values));
            }
            public override string ToString() => $"{nameof(Context)}.{Register}";
        }
    }
}

[21.5096]

using System;
using System.Collections.Generic;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects.ResourceLocationAccessors
{
    namespace ContextRegisters
    {
        public interface IRegisterType { }
        public class CurrentRegisterType : IRegisterType { }
        public class AddedRegisterType : IRegisterType { }
        public class RemovedRegisterType : IRegisterType { }
        public interface IContextRegister
        {
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectContext context)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType;
            public void Set<TResource, TUnit>(EffectContext context, Unit<TUnit> value)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType;
        }
        public class ContextRegister<TRegisterType> : IContextRegister where TRegisterType : IRegisterType
        {
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectContext context)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                yield return context.GetResource<TResource, TUnit, ContextRegister<TRegisterType>>();
            }
            public void Set<TResource, TUnit>(EffectContext context, Unit<TUnit> value)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                context.SetResource<TResource, TUnit, ContextRegister<TRegisterType>>(value);
            }
            public override string ToString() => typeof(TRegisterType).Name;
        }
        [ProvideSourceInfo][Serializable] public sealed class Current : ContextRegister<CurrentRegisterType> { }
        [ProvideSourceInfo][Serializable] public sealed class Added : ContextRegister<AddedRegisterType> { }
        [ProvideSourceInfo][Serializable] public sealed class Removed : ContextRegister<RemovedRegisterType> { }
    }
    namespace Get
    {
        using ContextRegisters;
        [ProvideSourceInfo]
        [Serializable]
        public class Context : IResourceLocationGet
        {
            [SerializeReference, ShowSerializeReference]
            public IContextRegister Register;
            public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                return Register.Get<TResource, TUnit>(data.Context);
            }
            public override string ToString() => $"{nameof(Context)}.{Register}";
        }
    }
    namespace Set
    {
        using ContextRegisters;
        [ProvideSourceInfo]
        [Serializable]
        public class Context : IResourceLocationSet
        {
            [SerializeReference, ShowSerializeReference]
            public IContextRegister Register;
            [SerializeReference, ShowSerializeReference]
            public IResourceOperator SetAs;
            public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
                where TResource : Resource<TUnit>
                where TUnit : IUnitType {
                Register.Set<TResource, TUnit>(data.Context, SetAs.OperateEnum(values));
            }
            public override string ToString() => $"{nameof(Context)}.{Register}";
        }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/EffectModes.cs at line 1 [26.291]

B:BD[26.291] → [17.38995:44685]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public interface IDelayedEffect
    {
        void DelayedAction(EffectInput data);
    }
    public interface IImmediateEffect
    {
        void ImmediateAction(EffectContext context, IEffect effect);
    }
    public interface IEffectMode
    {
        void Apply(EffectContext context);
        void Effect(EffectContext context, IEffect effect);
    }
    [Serializable]
    public class DelayedEffect : IImmediateEffect, IDelayedEffect
    {
        IEffect _effect;
        public void DelayedAction(EffectInput data) {
            _effect.Apply(data);
            // direction towards target
            var directionVector = (data.Context.EffectLocation.position - data.Context.Caster.position).normalized;
            directionVector.y = 0;
            var direction = Quaternion.LookRotation(directionVector, Vector3.up);
            var appliedResource = data.Context.GetAllResourcesInRegister<Added>();
            data.Context.EffectSystem.ApplyTagsEffect(appliedResource, data.Context.EffectLocation, direction, data.Context.AreaOfEffect);
        }
        public void ImmediateAction(EffectContext context, IEffect effect) {
            if (effect != null) {
                _effect = effect;
                context.EffectsToTrigger.Add(this);
            }
        }
    }
    [Serializable]
    public class ImmediateEffect : IImmediateEffect
    {
        [SerializeReference, ShowSerializeReference]
        AoeShapes.IAoeShape _areaOfEffect;
        public void ImmediateAction(EffectContext context, IEffect effect) {
            if (effect != null) {
                // direction towards target
                var directionVector = (context.EffectLocation.position - context.Caster.position).normalized;
                directionVector.y = 0;
                var direction = Quaternion.LookRotation(directionVector, Vector3.up);
                EffectInput data = new(context, Enumerable.Empty<Transform>(), StatModifierAccessor.Permanent);
                var areaOfEffect = _areaOfEffect.AreaOfEffect(data);
                // Copy the location of the effect and merge with the direction caster -> target
                GameObject tmpGo = new();
                tmpGo.transform.position = context.EffectLocation.position;
                tmpGo.transform.rotation = direction;
                data.Affected = areaOfEffect.GetAffectedUnits(tmpGo.transform);
                GameObject.Destroy(tmpGo);
                effect.Apply(data);
                var appliedResource = context.GetAllResourcesInRegister<Added>();
                context.EffectSystem.ApplyTagsEffect(appliedResource, context.EffectLocation, direction, areaOfEffect);
            }
        }
    }
    [Serializable]
    public class ImmediateWeave : IImmediateEffect
    {
        public void ImmediateAction(EffectContext context, IEffect effect) {
            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);
            if (effect != null) {
                effect.Apply(data);
                data.Affected = context.GetAffectedUnits();
            }
            Materialize(data);
        }
        void Materialize(EffectInput data) {
            foreach (var effect in data.Context.EffectsToTrigger) {
                effect.DelayedAction(data);
            }
            data.Context.EffectsToTrigger.Clear();
        }
    }
    [Serializable]
    public class PeriodicWeave : IImmediateEffect
    {
        [SerializeReference, ShowSerializeReference]
        public AoeShapes.IAoeShape AreaOfEffect;
        [SerializeReference, ShowSerializeReference]
        public Triggers.ITrigger ApplyTrigger;
        [SerializeReference, ShowSerializeReference]
        public Triggers.ITrigger EndTrigger;
        public bool IsPermanent;
        public void ImmediateAction(EffectContext context, IEffect effect) {
            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);
            if (effect != null) {
                effect.Apply(data);
                data.Affected = context.GetAffectedUnits();
            }
            Materialize(data);
        }
        void Materialize(EffectInput data) {
            var areaOfEffect = AreaOfEffect.AreaOfEffect(data);
            /// Move all effects in context to condition context.
            List<IDelayedEffect> effectsToTrigger = new(data.Context.EffectsToTrigger);
            data.Context.EffectsToTrigger.Clear();
            var origin = data.Context.Caster;
            foreach (var affectedPawn in data.Affected) {
                var condition = IsPermanent ? affectedPawn.gameObject.AddComponent<PawnCondition>() : affectedPawn.gameObject.AddComponent<TransientPawnCondition>();
                condition.EndTrigger = EndTrigger?.ShallowCopy();
                condition.ApplyTrigger = ApplyTrigger?.ShallowCopy();
                condition.Origin = origin;
                condition.Context = new EffectContext() {
                    AreaOfEffect = areaOfEffect,
                    Caster = affectedPawn,
                    EffectLocation = affectedPawn,
                    EffectsToTrigger = effectsToTrigger
                };
                condition.Apply();
            }
        }
    }
}

[26.291]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public interface IDelayedEffect
    {
        void DelayedAction(EffectInput data);
    }
    public interface IImmediateEffect
    {
        void ImmediateAction(EffectContext context, IEffect effect);
    }
    public interface IEffectMode
    {
        void Apply(EffectContext context);
        void Effect(EffectContext context, IEffect effect);
    }
    [ProvideSourceInfo]
    [Serializable]
    public class DelayedEffect : IImmediateEffect, IDelayedEffect
    {
        IEffect _effect;
        public void DelayedAction(EffectInput data) {
            _effect.Apply(data);
            // direction towards target
            var directionVector = (data.Context.EffectLocation.position - data.Context.Caster.position).normalized;
            directionVector.y = 0;
            var direction = Quaternion.LookRotation(directionVector, Vector3.up);
            var appliedResource = data.Context.GetAllResourcesInRegister<Added>();
            data.Context.EffectSystem.ApplyTagsEffect(appliedResource, data.Context.EffectLocation, direction, data.Context.AreaOfEffect);
        }
        public void ImmediateAction(EffectContext context, IEffect effect) {
            if (effect != null) {
                _effect = effect;
                context.EffectsToTrigger.Add(this);
            }
        }
    }
    [ProvideSourceInfo]
    [Serializable]
    public class ImmediateEffect : IImmediateEffect
    {
        [SerializeReference, ShowSerializeReference]
        AoeShapes.IAoeShape _areaOfEffect;
        public void ImmediateAction(EffectContext context, IEffect effect) {
            if (effect != null) {
                // direction towards target
                var directionVector = (context.EffectLocation.position - context.Caster.position).normalized;
                directionVector.y = 0;
                var direction = Quaternion.LookRotation(directionVector, Vector3.up);
                EffectInput data = new(context, Enumerable.Empty<Transform>(), StatModifierAccessor.Permanent);
                var areaOfEffect = _areaOfEffect.AreaOfEffect(data);
                // Copy the location of the effect and merge with the direction caster -> target
                GameObject tmpGo = new();
                tmpGo.transform.position = context.EffectLocation.position;
                tmpGo.transform.rotation = direction;
                data.Affected = areaOfEffect.GetAffectedUnits(tmpGo.transform);
                GameObject.Destroy(tmpGo);
                effect.Apply(data);
                var appliedResource = context.GetAllResourcesInRegister<Added>();
                context.EffectSystem.ApplyTagsEffect(appliedResource, context.EffectLocation, direction, areaOfEffect);
            }
        }
    }
    [ProvideSourceInfo]
    [Serializable]
    public class ImmediateWeave : IImmediateEffect
    {
        public void ImmediateAction(EffectContext context, IEffect effect) {
            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);
            if (effect != null) {
                effect.Apply(data);
                data.Affected = context.GetAffectedUnits();
            }
            Materialize(data);
        }
        void Materialize(EffectInput data) {
            foreach (var effect in data.Context.EffectsToTrigger) {
                effect.DelayedAction(data);
            }
            data.Context.EffectsToTrigger.Clear();
        }
    }
    [ProvideSourceInfo]
    [Serializable]
    public class PeriodicWeave : IImmediateEffect
    {
        [SerializeReference, ShowSerializeReference]
        public AoeShapes.IAoeShape AreaOfEffect;
        [SerializeReference, ShowSerializeReference]
        public Triggers.ITrigger ApplyTrigger;
        [SerializeReference, ShowSerializeReference]
        public Triggers.ITrigger EndTrigger;
        public bool IsPermanent;
        public void ImmediateAction(EffectContext context, IEffect effect) {
            EffectInput data = new(context, context.GetAffectedUnits(), StatModifierAccessor.Permanent);
            if (effect != null) {
                effect.Apply(data);
                data.Affected = context.GetAffectedUnits();
            }
            Materialize(data);
        }
        void Materialize(EffectInput data) {
            var areaOfEffect = AreaOfEffect.AreaOfEffect(data);
            /// Move all effects in context to condition context.
            List<IDelayedEffect> effectsToTrigger = new(data.Context.EffectsToTrigger);
            data.Context.EffectsToTrigger.Clear();
            var origin = data.Context.Caster;
            foreach (var affectedPawn in data.Affected) {
                var condition = IsPermanent ? affectedPawn.gameObject.AddComponent<PawnCondition>() : affectedPawn.gameObject.AddComponent<TransientPawnCondition>();
                condition.EndTrigger = EndTrigger?.ShallowCopy();
                condition.ApplyTrigger = ApplyTrigger?.ShallowCopy();
                condition.Origin = origin;
                condition.Context = new EffectContext() {
                    AreaOfEffect = areaOfEffect,
                    Caster = affectedPawn,
                    EffectLocation = affectedPawn,
                    EffectsToTrigger = effectsToTrigger
                };
                condition.Apply();
            }
        }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/AoeEffect.cs at line 1 [26.2463]

B:BD[26.2463] → [26.2464:2479]

B:BD[26.2514] → [23.6567:6612]

∅:D[23.6612] → [26.2514:2534]

B:BD[26.2514] → [26.2514:2534]

∅:D[27.3235] → [26.2534:2569]

B:BD[26.2534] → [26.2534:2569]

B:BD[26.2569] → [23.6613:6615]

∅:D[23.6615] → [26.2569:2589]

B:BD[26.2569] → [26.2569:2589]

B:BD[26.2589] → [28.3725:3763]

∅:D[28.3763] → [26.2627:2634]

B:BD[26.2627] → [26.2627:2634]

B:BD[26.2634] → [22.5388:5442]

B:BD[22.5442] → [15.19396:19439]

∅:D[15.19439] → [23.6652:6654]

B:BD[23.6652] → [23.6652:6654]

B:BD[23.6654] → [5.21746:21860]

∅:D[5.21860] → [23.6730:6829]

B:BD[23.6730] → [23.6730:6829]

B:BD[23.6829] → [5.21861:21927]

∅:D[5.21927] → [23.6933:7065]

B:BD[23.6933] → [23.6933:7065]

B:BD[23.7065] → [5.21928:21995]

∅:D[5.21995] → [23.7170:7474]

B:BD[23.7170] → [23.7170:7474]

B:BD[23.7474] → [5.21996:22414]

∅:D[5.22414] → [23.7750:8155]

B:BD[23.7750] → [23.7750:8155]

B:BD[23.8155] → [5.22415:22915]

∅:D[5.22915] → [23.8515:8668]

B:BD[23.8515] → [23.8515:8668]

B:BD[23.8668] → [29.79248:79353]

∅:D[29.79353] → [23.8774:8919]

B:BD[23.8774] → [23.8774:8919]

B:BD[23.8919] → [5.22916:23275]

B:BD[5.23275] → [29.79354:79425]

∅:D[29.79425] → [5.23348:23421]

B:BD[5.23348] → [5.23348:23421]

∅:D[5.23421] → [23.9281:9349]

B:BD[23.9281] → [23.9281:9349]

∅:D[27.3404] → [26.3136:3154]

∅:D[23.9349] → [26.3136:3154]

B:BD[26.3136] → [26.3136:3154]

B:BD[26.3154] → [23.9350:9354]

∅:D[23.9354] → [26.3154:3155]

B:BD[26.3154] → [26.3154:3155]

using System;
using System.Linq;
using CareBoo.Serially;
using UnityEngine;
namespace TagFighter.Effects
{
    [Serializable]
    public class AoeEffect : IEffect
    {
        [SerializeReference, ShowSerializeReference]
        public AoeShapes.IAoeShape Shape;
        public void Apply(EffectInput data) {
            data.Context.AreaOfEffect = Shape.AreaOfEffect(data);
        }
    }
    namespace AoeShapes
    {
        public interface IAoeShape
        {
            public IAreaOfEffect AreaOfEffect(EffectInput data);
        }
        [Serializable]
        public class Single : IAoeShape
        {
            SingleTarget _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                return _areaOfEffect.ShallowCopy();
            }
        }
        [Serializable]
        public class Circle : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Radius;
            CircleArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius is a 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 
                _areaOfEffect.Radius = (float)Radius.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
        [Serializable]
        public class Cone : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Radius;
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Angle;
            ConeArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius and Angle are a 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 
                _areaOfEffect.Radius = (float)Radius.Get(data).First();
                _areaOfEffect.Angle = (float)Angle.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
        [Serializable]
        public class Path : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Width;
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Length;
            PathArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius and Length are a 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 
                _areaOfEffect.Width = (float)Width.Get(data).First();
                _areaOfEffect.Length = (float)Length.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
    }
}

[26.2463]

using System;
using System.Linq;
using CareBoo.Serially;
using UnityEngine;
namespace TagFighter.Effects
{
    [ProvideSourceInfo]
    [Serializable]
    public class AoeEffect : IEffect
    {
        [SerializeReference, ShowSerializeReference]
        public AoeShapes.IAoeShape Shape;
        public void Apply(EffectInput data) {
            data.Context.AreaOfEffect = Shape.AreaOfEffect(data);
        }
    }
    namespace AoeShapes
    {
        public interface IAoeShape
        {
            public IAreaOfEffect AreaOfEffect(EffectInput data);
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Single : IAoeShape
        {
            SingleTarget _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                return _areaOfEffect.ShallowCopy();
            }
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Circle : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Radius;
            CircleArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius is a 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 
                _areaOfEffect.Radius = (float)Radius.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Cone : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Radius;
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Angle;
            ConeArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius and Angle are a 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 
                _areaOfEffect.Radius = (float)Radius.Get(data).First();
                _areaOfEffect.Angle = (float)Angle.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
        [ProvideSourceInfo]
        [Serializable]
        public class Path : IAoeShape
        {
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Width;
            public ResourceInfoGet<IResourceTypeAccessor, ResourceLocationAccessors.Get.Context> Length;
            PathArea _areaOfEffect;
            public IAreaOfEffect AreaOfEffect(EffectInput data) {
                /// Currently Radius and Length are a 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 
                _areaOfEffect.Width = (float)Width.Get(data).First();
                _areaOfEffect.Length = (float)Length.Get(data).First();
                return _areaOfEffect.ShallowCopy();
            }
        }
    }
}

Replacement in Assets/Scripts/Combat/Runes/Effects/AccumulateResourceEffect.cs at line 1 [21.7525]

B:BD[21.7525] → [21.7526:7576]

B:BD[21.7576] → [22.5445:5465]

∅:D[22.5465] → [21.7576:7601]

B:BD[21.7576] → [21.7576:7601]

∅:D[10.14740] → [21.7630:7705]

B:BD[21.7630] → [21.7630:7705]

B:BD[22.6674] → [22.6674:6729]

B:BD[22.6729] → [7.15862:16026]

∅:D[22.6797] → [21.7963:7965]

∅:D[23.9519] → [21.7963:7965]

∅:D[10.14815] → [21.7963:7965]

∅:D[7.16026] → [21.7963:7965]

B:BD[21.7963] → [21.7963:7965]

B:BD[21.7965] → [5.23424:23471]

B:BD[5.23471] → [7.16027:16092]

∅:D[7.16092] → [10.14885:14887]

B:BD[10.14885] → [10.14885:14887]

B:BD[10.14887] → [7.16093:16142]

∅:D[22.7051] → [21.8165:8167]

∅:D[7.16142] → [21.8165:8167]

B:BD[21.8165] → [21.8165:8167]

B:BD[21.8167] → [5.23472:23520]

∅:D[5.23520] → [22.7113:7115]

B:BD[22.7113] → [22.7113:7115]

B:BD[22.7115] → [5.23521:23562]

∅:D[5.23562] → [22.7169:7363]

B:BD[22.7169] → [22.7169:7363]

B:BD[22.7363] → [7.16143:16392]

∅:D[22.7468] → [21.8261:8263]

∅:D[23.9766] → [21.8261:8263]

∅:D[10.15002] → [21.8261:8263]

∅:D[7.16392] → [21.8261:8263]

B:BD[21.8261] → [21.8261:8263]

B:BD[21.8263] → [5.23563:23610]

B:BD[5.23610] → [7.16393:16476]

∅:D[7.16476] → [10.15090:15092]

B:BD[10.15090] → [10.15090:15092]

∅:D[10.15092] → [22.7631:7668]

B:BD[22.7631] → [22.7631:7668]

B:BD[22.7668] → [7.16477:16556]

∅:D[7.16556] → [22.7748:7790]

B:BD[22.7748] → [22.7748:7790]

B:BD[22.7790] → [7.16557:16606]

∅:D[7.16606] → [21.8485:8487]

B:BD[21.8485] → [21.8485:8487]

B:BD[21.8487] → [5.23611:23729]

∅:D[5.23729] → [10.15237:15311]

B:BD[10.15237] → [10.15237:15311]

B:BD[10.15311] → [5.23730:23770]

∅:D[5.23770] → [10.15364:15377]

B:BD[10.15364] → [10.15364:15377]

∅:D[22.7917] → [21.8487:8489]

∅:D[10.15377] → [21.8487:8489]

B:BD[21.8487] → [21.8487:8489]

B:BD[21.8489] → [13.5119:5190]

∅:D[13.5190] → [30.818:1154]

B:BD[10.15457] → [30.818:1154]

∅:D[30.1154] → [10.15660:15671]

B:BD[10.15660] → [10.15660:15671]

B:BD[21.8843] → [21.8843:8851]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using UnityEngine;
namespace TagFighter.Effects
{
    [Serializable]
    public class UnaryResourceEffect : IEffect
    {
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> From;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;
        public void Apply(EffectInput data) {
            var effectName = $"UnaryEffect ({From}) To ({To})";
            Debug.Log($"{effectName} : Apply");
            var resourceFrom = From.Get(data);
            To.Set(data, resourceFrom);
        }
    }
    [Serializable]
    public class BinaryResourceEffect : IEffect
    {
        [SerializeReference, ShowSerializeReference]
        public IResourceOperator Operator;
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromA;
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromB;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;
        public void Apply(EffectInput data) {
            var effectName = $"BinaryEffect({FromA} {Operator} {FromB})To({To})";
            if (Operator == null) {
                Debug.Log($"{effectName}: Apply missing operator, skipping");
                return;
            }
            Debug.Log($"{effectName} : Apply");
            var resourceFromA = FromA.Get(data).ToList();
            var resourceFromB = FromB.Get(data).ToList();
            var manipulated = Combine(resourceFromA, resourceFromB);
            To.Set(data, manipulated);
        }
        IEnumerable<double> Combine(List<double> a, List<double> b) {
            var (shortList, maybeLongList) = a.Count switch {
                1 => (a, b),
                _ => (b, a)
            };
            var repeatedShortList = Enumerable.Repeat(shortList, int.MaxValue).SelectMany((val) => val);
            return maybeLongList.Zip(repeatedShortList, (x, y) => Operator.Operate(x, y));
        }
    }
}

[21.7525]

using System;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using UnityEngine;
namespace TagFighter.Effects
{
    [ProvideSourceInfo]
    [Serializable]
    public class UnaryResourceEffect : IEffect
    {
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> From;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;
        public void Apply(EffectInput data) {
            var effectName = $"UnaryEffect ({From}) To ({To})";
            Debug.Log($"{effectName} : Apply");
            var resourceFrom = From.Get(data);
            To.Set(data, resourceFrom);
        }
    }
    [ProvideSourceInfo]
    [Serializable]
    public class BinaryResourceEffect : IEffect
    {
        [SerializeReference, ShowSerializeReference]
        public IResourceOperator Operator;
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromA;
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromB;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;
        public void Apply(EffectInput data) {
            var effectName = $"BinaryEffect({FromA} {Operator} {FromB})To({To})";
            if (Operator == null) {
                Debug.Log($"{effectName}: Apply missing operator, skipping");
                return;
            }
            Debug.Log($"{effectName} : Apply");
            var resourceFromA = FromA.Get(data).ToList();
            var resourceFromB = FromB.Get(data).ToList();
            var manipulated = Combine(resourceFromA, resourceFromB);
            To.Set(data, manipulated);
        }
        IEnumerable<double> Combine(List<double> a, List<double> b) {
            var (shortList, maybeLongList) = a.Count switch {
                1 => (a, b),
                _ => (b, a)
            };
            var repeatedShortList = Enumerable.Repeat(shortList, int.MaxValue).SelectMany((val) => val);
            return maybeLongList.Zip(repeatedShortList, (x, y) => Operator.Operate(x, y));
        }
    }
}

Replacement in Assets/Scenes/SampleScene.unity at line 41 [31.780110080]

B:BD[31.780111327] → [17.50009:50087]

  m_IndirectSpecularColor: {r: 0.18028352, g: 0.22571376, b: 0.3069224, a: 1}

[31.780111327]

[31.780111406]

  m_IndirectSpecularColor: {r: 0.18028378, g: 0.22571412, b: 0.30692285, a: 1}

Replacement in Assets/Scenes/SampleScene.unity at line 5764 [31.780110080]

B:BD[31.780121071] → [32.982:1063]

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

[31.780121071]

[33.33888019]

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

Replacement in Assets/Scenes/SampleScene.unity at line 7821 [31.780110080]
B:BD[31.780161886] → [17.50264:50302]
```
    m_SensorSize: {x: 1.910909, y: 1}
```
[31.780161886]
[31.780161925]
```
    m_SensorSize: {x: 2.14826, y: 1}
```

Replacement in Assets/Scenes/SampleScene.unity at line 7837 [31.780110080]

B:BD[31.780162310] → [32.1104:1185]

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

[31.780162310]

[33.33918016]

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