itai.sharim/TagFight - Change J5CTPTTJ22V4MMQ3IZ2LUJE7GP35I4NS2JIZ2HQRNIVJF3ERYELAC

add basic lens

Created by itai.sharim on July 30, 2023

J5CTPTTJ22V4MMQ3IZ2LUJE7GP35I4NS2JIZ2HQRNIVJF3ERYELAC

Dependencies

In channels

main

Change contents

Replacement in Assets/Scripts/Tester.cs at line 1 [3.286]

B:BD[3.286] → [2.55602:63794]

using System.Collections;
using TagFighter;
using TagFighter.Events;
using TagFighter.Resources;
using Testing.Actions;
using Testing.Line;
using Testing.TimeDialation;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
public class Tester : MonoBehaviour
{
    [SerializeField] Vector3 _forceToApply;
    [SerializeField] Transform _affected;
    [SerializeField] LayerMask _unitMovementLayerMask;
    [SerializeField] ForceMode _forceMode;
    [SerializeField] EventAggregator _eventAggregator;
    [SerializeField] bool _shouldTestTags = false;
    [SerializeField] bool _shouldTestPhysics = false;
    [SerializeField] bool _shouldTestPawnConditions = false;
    [SerializeField] bool _shouldRunAutoTests = false;
    Renderer _r;
    Rigidbody _rb;
    NavMeshAgent _nma;
    bool _pushed;
    Vector3 _resetPosition;
    protected void Start() {
        if (_affected) {
            _r = _affected.GetComponent<Renderer>();
            _rb = _affected.GetComponent<Rigidbody>();
            _nma = _affected.GetComponent<NavMeshAgent>();
            _resetPosition = _affected.transform.position;
        }
        Reset();
    }
    protected void Update() {
        if (_shouldTestTags) {
            TestTags();
        }
        if (_shouldTestPhysics) {
            TestPhysics();
        }
        if (_shouldTestPawnConditions) {
            TestAddPawnCondition();
        }
        if (_shouldRunAutoTests) {
            AutoTests();
        }
    }
    void TestAddPawnCondition() {
        if (Input.GetKeyDown(KeyCode.T)) {
            var condition = _affected.gameObject.AddComponent<TagFighter.Effects.PawnCondition>();
            condition.Apply();
        }
    }
    void TestTags() {
        if (Input.GetKeyDown(KeyCode.L)) {
            var color = UnityEngine.Random.Range(0, 3);
            switch (color) {
                case 0: {
                        var modifier = new StatModifier<BlueTagUnit> {
                            Amount = (Unit<BlueTagUnit>)1
                        };
                        _affected.GetComponent<BlueTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
                case 1: {
                        var modifier = new StatModifier<RedTagUnit> {
                            Amount = (Unit<RedTagUnit>)1
                        };
                        _affected.GetComponent<RedTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
                case 2: {
                        var modifier = new StatModifier<GreenTagUnit> {
                            Amount = (Unit<GreenTagUnit>)1
                        };
                        _affected.GetComponent<GreenTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
            }
        }
    }
    void AutoTests() {
        if (Input.GetKeyDown(KeyCode.T)) {
            if (Input.GetKey(KeyCode.LeftShift)) {
                Test();
            }
        }
    }
    void TestPhysics() {
        if (Input.GetKeyDown(KeyCode.T)) {
            if (!Input.GetKey(KeyCode.LeftShift)) {
                _pushed = true;
            }
        }
        if (Input.GetKeyDown(KeyCode.B) && !EventSystem.current.IsPointerOverGameObject()) {
            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray, out var hit)) {
                var objectHit = hit.transform;
                if (_unitMovementLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                    _nma.Warp(hit.point);
                }
            }
        }
        if (Input.GetKeyDown(KeyCode.R)) {
            Reset();
        }
        if (Input.GetKeyDown(KeyCode.P)) {
            print($"Velocity ({_rb.velocity}), Magnitude {_rb.velocity.magnitude}");
            print($"world bounds {_r.bounds} local bounds {_r.localBounds}");
        }
    }
    protected void FixedUpdate() {
        if (_rb != null && !_rb.isKinematic && _nma.isOnNavMesh && _rb.velocity.sqrMagnitude < 0.25f) {
            if (Physics.Raycast(_affected.transform.position, Vector3.down, _r.bounds.extents.y + 0.1f, _unitMovementLayerMask)) {
                _rb.isKinematic = true;
                _nma.updatePosition = true;
                _nma.updateRotation = true;
                _nma.Warp(_affected.transform.position);
            }
            //nma.enabled = true;
        }
        if (_pushed) {
            // nma.enabled = false;
            _nma.updatePosition = false;
            _nma.updateRotation = false;
            _rb.isKinematic = false;
            _rb.AddForce(_forceToApply, _forceMode);
            _pushed = false;
        }
    }
    void Reset() {
        if (_rb != null) {
            _rb.isKinematic = true;
        }
        if (_nma) {
            _nma.updatePosition = true;
            _nma.updateRotation = true;
            _nma.enabled = true;
            _pushed = false;
        }
        if (_affected) {
            _affected.transform.position = _resetPosition;
        }
    }
    [SerializeField] Weaver _actionTesterWeaver;
    [SerializeField] Transform _actionTesterTransform1;
    [SerializeField] Transform _actionTesterTransform2;
    void Test() {
        TimeDialationTester timeDialationTester = new(_eventAggregator);
        timeDialationTester.TestAll();
        LineTester lineTester = new();
        lineTester.TestAll();
        ActionsTester actionsTester = new(_actionTesterWeaver, _actionTesterTransform1, _actionTesterTransform2);
        actionsTester.TestAll();
    }
}
namespace Testing.Actions
{
    public class ActionsTester
    {
        Weaver _weaver;
        Transform _transform1;
        Transform _transform2;
        public ActionsTester(Weaver weaver, Transform transform1, Transform transform2) {
            _weaver = weaver;
            _transform1 = transform1;
            _transform2 = transform2;
        }
        public void TestAll() {
            TestFollowActionConcreteEqual();
            TestFollowActionInterfaceEqual();
            TestActionInterfaceNotEqual();
            TestMoveToActionConcreteEqual();
            TestMoveToActionInterfaceEqual();
        }
        public void TestFollowActionConcreteEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var action1 = new FollowAction(_weaver, _transform1);
            var action2 = new FollowAction(_weaver, _transform1);
            if (action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestFollowActionInterfaceEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new FollowAction(_weaver, _transform1);
            IAction action2 = new FollowAction(_weaver, _transform1);
            if (action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestActionInterfaceNotEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new FollowAction(_weaver, _transform1);
            IAction action2 = new MoveToAction(_weaver, _transform1.position);
            if (!action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }

[3.286]

[2.63794]

using System;
using System.Collections;
using CareBoo.Serially;
using TagFighter;
using TagFighter.Events;
using TagFighter.Resources;
using Testing.Actions;
using Testing.Line;
using Testing.Optics;
using Testing.TimeDialation;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
public class Tester : MonoBehaviour
{
    [SerializeField] Vector3 _forceToApply;
    [SerializeField] Transform _affected;
    [SerializeField] LayerMask _unitMovementLayerMask;
    [SerializeField] ForceMode _forceMode;
    [SerializeField] EventAggregator _eventAggregator;
    [SerializeField] bool _shouldTestTags = false;
    [SerializeField] bool _shouldTestPhysics = false;
    [SerializeField] bool _shouldTestPawnConditions = false;
    [SerializeField] bool _shouldRunAutoTests = false;
    Renderer _r;
    Rigidbody _rb;
    NavMeshAgent _nma;
    bool _pushed;
    Vector3 _resetPosition;
    protected void Start() {
        if (_affected) {
            _r = _affected.GetComponent<Renderer>();
            _rb = _affected.GetComponent<Rigidbody>();
            _nma = _affected.GetComponent<NavMeshAgent>();
            _resetPosition = _affected.transform.position;
        }
        Reset();
    }
    protected void Update() {
        if (_shouldTestTags) {
            TestTags();
        }
        if (_shouldTestPhysics) {
            TestPhysics();
        }
        if (_shouldTestPawnConditions) {
            TestAddPawnCondition();
        }
        if (_shouldRunAutoTests) {
            AutoTests();
        }
    }
    void TestAddPawnCondition() {
        if (Input.GetKeyDown(KeyCode.T)) {
            var condition = _affected.gameObject.AddComponent<TagFighter.Effects.PawnCondition>();
            condition.Apply();
        }
    }
    void TestTags() {
        if (Input.GetKeyDown(KeyCode.L)) {
            var color = UnityEngine.Random.Range(0, 3);
            switch (color) {
                case 0: {
                        var modifier = new StatModifier<BlueTagUnit> {
                            Amount = (Unit<BlueTagUnit>)1
                        };
                        _affected.GetComponent<BlueTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
                case 1: {
                        var modifier = new StatModifier<RedTagUnit> {
                            Amount = (Unit<RedTagUnit>)1
                        };
                        _affected.GetComponent<RedTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
                case 2: {
                        var modifier = new StatModifier<GreenTagUnit> {
                            Amount = (Unit<GreenTagUnit>)1
                        };
                        _affected.GetComponent<GreenTag>().AddCurrentModifier(modifier, System.Threading.CancellationToken.None);
                        break;
                    }
            }
        }
    }
    void AutoTests() {
        if (Input.GetKeyDown(KeyCode.T)) {
            if (Input.GetKey(KeyCode.LeftShift)) {
                Test();
            }
        }
    }
    void TestPhysics() {
        if (Input.GetKeyDown(KeyCode.T)) {
            if (!Input.GetKey(KeyCode.LeftShift)) {
                _pushed = true;
            }
        }
        if (Input.GetKeyDown(KeyCode.B) && !EventSystem.current.IsPointerOverGameObject()) {
            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray, out var hit)) {
                var objectHit = hit.transform;
                if (_unitMovementLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                    _nma.Warp(hit.point);
                }
            }
        }
        if (Input.GetKeyDown(KeyCode.R)) {
            Reset();
        }
        if (Input.GetKeyDown(KeyCode.P)) {
            print($"Velocity ({_rb.velocity}), Magnitude {_rb.velocity.magnitude}");
            print($"world bounds {_r.bounds} local bounds {_r.localBounds}");
        }
    }
    protected void FixedUpdate() {
        if (_rb != null && !_rb.isKinematic && _nma.isOnNavMesh && _rb.velocity.sqrMagnitude < 0.25f) {
            if (Physics.Raycast(_affected.transform.position, Vector3.down, _r.bounds.extents.y + 0.1f, _unitMovementLayerMask)) {
                _rb.isKinematic = true;
                _nma.updatePosition = true;
                _nma.updateRotation = true;
                _nma.Warp(_affected.transform.position);
            }
            //nma.enabled = true;
        }
        if (_pushed) {
            // nma.enabled = false;
            _nma.updatePosition = false;
            _nma.updateRotation = false;
            _rb.isKinematic = false;
            _rb.AddForce(_forceToApply, _forceMode);
            _pushed = false;
        }
    }
    void Reset() {
        if (_rb != null) {
            _rb.isKinematic = true;
        }
        if (_nma) {
            _nma.updatePosition = true;
            _nma.updateRotation = true;
            _nma.enabled = true;
            _pushed = false;
        }
        if (_affected) {
            _affected.transform.position = _resetPosition;
        }
    }
    [ContextMenuItem("Test", "TestOptics")]
    [SerializeField]
    OpticsTester opticsTester;
    [SerializeField] ActionsTester actionsTester;
    void Test() {
        //TimeDialationTester timeDialationTester = new(_eventAggregator);
        //timeDialationTester.TestAll();
        //LineTester lineTester = new();
        //lineTester.TestAll();
        //ActionsTester actionsTester = new(_actionTesterWeaver, _actionTesterTransform1, _actionTesterTransform2);
        //actionsTester.TestAll();
        opticsTester.TestAll();
    }
    void TestOptics() {
        opticsTester.TestAll();
    }
}
namespace Testing.Optics
{
    using CareBoo.Serially;
    using System;
    using TagFighter.Effects;
    using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
    using TagFighter.Optics;
    using TagFighter.Resources;
    public interface IOpticsVisitor
    {
        public Lens<Transform, int> VisitTransform(PawnAccessor pawnLensCreator);
        public Lens<EffectContext, int> VisitContext(ContextAccessor contextLensCreator);
    }
    public class OpticsVisitor<TResource, TUnitType> : IOpticsVisitor
        where TResource : Resource<TUnitType>
        where TUnitType : IUnitType
    {
        public Lens<Transform, int> VisitTransform(PawnAccessor pawnLensCreator) {
            return pawnLensCreator.CreateSpecific<Resource<TUnitType>, TUnitType>();
        }
        public Lens<EffectContext, int> VisitContext(ContextAccessor contextLensCreator) {
            return contextLensCreator.CreateSpecific<Resource<TUnitType>, TUnitType>();
        }
    }
    [ProvideSourceInfo][Serializable] public sealed class BlueTagVisitor : OpticsVisitor<BlueTag, BlueTagUnit> { };
    [ProvideSourceInfo][Serializable] public sealed class RedTagVisitor : OpticsVisitor<RedTag, RedTagUnit> { };
    [ProvideSourceInfo][Serializable] public sealed class GreenTagVisitor : OpticsVisitor<GreenTag, GreenTagUnit> { };
    public interface IPawnAccessor
    {
        public Lens<Transform, int> Create();
        public Lens<Transform, int> CreateSpecific<TResource, TUnitType>() where TResource : Resource<TUnitType> where TUnitType : IUnitType;
    };
    [Serializable]
    public class PawnAccessor : IPawnAccessor
    {
        [SerializeReference, ShowSerializeReference]
        public IOpticsVisitor ResourceLensVisitor;
        [SerializeReference, ShowSerializeReference]
        public IResourceStatLensCreator ResourceLensCreator; // Current/Capacity
        public Lens<Transform, int> Create() {
            return ResourceLensVisitor.VisitTransform(this);
        }
        public Lens<Transform, int> CreateSpecific<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            var resource = new Lens<Transform, TResource>(t => t.GetComponent<TResource>(), (t, r) => t);
            var statLens = ResourceLensCreator.Create<TResource, TUnitType>();
            var valueLens = new Lens<Unit<TUnitType>, int>(u => u.AsPrimitive(), (u, v) => u = (Unit<TUnitType>)v);
            var lens = resource.Compose(statLens).Compose(valueLens);
            return lens;
        }
    }
    public interface IContextAccessor
    {
        public Lens<EffectContext, int> Create();
        public Lens<EffectContext, int> CreateSpecific<TResource, TUnitType>() where TResource : Resource<TUnitType> where TUnitType : IUnitType;
    }
    public class ContextAccessor : IContextAccessor
    {
        // Resource/UnitType
        [SerializeReference, ShowSerializeReference]
        public IOpticsVisitor ResourceLensVisitor;
        // Register
        [SerializeReference, ShowSerializeReference]
        public IRegisterTypeLensCreator RegisterTypeLensCreator;
        public Lens<EffectContext, int> Create() {
            return ResourceLensVisitor.VisitContext(this);
        }
        public Lens<EffectContext, int> CreateSpecific<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            var registerLens = RegisterTypeLensCreator.Create<TResource, TUnitType>();
            var valueLens = new Lens<Unit<TUnitType>, int>(u => u.AsPrimitive(), (u, v) => u = (Unit<TUnitType>)v);
            return registerLens.Compose(valueLens);
        }
    }
    public interface IEffectInputLensCreator
    {
        public Lens<EffectContext, Unit<TUnitType>> LensContext<TResource, TUnitType>(IRegisterTypeLensCreator register)
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType;
        public Lens<Transform, Unit<TUnitType>> CreateLensTransform<TResource, TUnitType>(IResourceStatLensCreator stat)
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType;
    }
    public class EffectInputLensCreator : IEffectInputLensCreator
    {
        public Lens<EffectContext, Unit<TUnitType>> LensContext<TResource, TUnitType>(IRegisterTypeLensCreator register)
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            return register.Create<TResource, TUnitType>();
        }
        public Lens<Transform, Unit<TUnitType>> CreateLensTransform<TResource, TUnitType>(IResourceStatLensCreator stat)
                where TResource : Resource<TUnitType>
                where TUnitType : IUnitType {
            var transformLen = new Lens<Transform, TResource>(t => t.GetComponent<TResource>(), (t, r) => t);
            var statLens = stat.Create<TResource, TUnitType>();
            return transformLen.Compose(statLens);
        }
    }
    public interface IRegisterTypeLensCreator
    {
        public Lens<EffectContext, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType;
    }
    public class CurrentRegisterTypeLensCreator : IRegisterTypeLensCreator
    {
        public Lens<EffectContext, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            return new Lens<EffectContext, Unit<TUnitType>>(
                context => context.GetResource<TResource, TUnitType, Current>(),
                (context, v) => {
                    context.SetResource<TResource, TUnitType, Current>(v);
                    return context;
                }
                );
        }
    }
    [Serializable]
    public class OpticsTester
    {
        [SerializeField] Transform _transform;
        [SerializeReference, ShowSerializeReference] IPawnAccessor _accessor;
        public void TestAll() {
            Debug.Log(_accessor.Create().Get(_transform));
        }
    }
}
namespace Testing.Actions
{
    [Serializable]
    public class ActionsTester
    {
        [SerializeField] Weaver _weaver;
        [SerializeField] Transform _transform1;
        [SerializeField] Transform _transform2;
        public void TestAll() {
            TestFollowActionConcreteEqual();
            TestFollowActionInterfaceEqual();
            TestActionInterfaceNotEqual();
            TestMoveToActionConcreteEqual();
            TestMoveToActionInterfaceEqual();
        }
        public void TestFollowActionConcreteEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var action1 = new FollowAction(_weaver, _transform1);
            var action2 = new FollowAction(_weaver, _transform1);
            if (action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestFollowActionInterfaceEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new FollowAction(_weaver, _transform1);
            IAction action2 = new FollowAction(_weaver, _transform1);
            if (action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestActionInterfaceNotEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new FollowAction(_weaver, _transform1);
            IAction action2 = new MoveToAction(_weaver, _transform1.position);
            if (!action1.IsSimilarAction(action2)) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }

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

B:BD[4.6208] → [5.8270:12509]

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;
                });
            }
        }
    }
}

[4.6208]

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;
                });
            }
        }
    }
}

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

B:BD[6.305] → [6.306:370]

B:BD[6.390] → [6.390:425]

B:BD[6.425] → [7.14688:14740]

∅:D[7.14740] → [6.476:554]

B:BD[6.476] → [6.476:554]

B:BD[6.554] → [8.15822:15903]

∅:D[8.15903] → [6.673:843]

B:BD[6.673] → [6.673:843]

B:BD[6.843] → [8.15904:15998]

∅:D[8.15998] → [6.975:1068]

B:BD[6.975] → [6.975:1068]

using System.Collections.Generic;
using TagFighter.Resources;
namespace TagFighter.Effects
{
    public interface IResourceLocationAccessor { }
    public interface IResourceLocationGet : IResourceLocationAccessor
    {
        public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType;
    }
    public interface IResourceLocationSet : IResourceLocationAccessor
    {
        public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType;
    }
}

[6.305]

using System.Collections.Generic;
using TagFighter.Resources;
namespace TagFighter.Effects
{
    public interface IResourceLocationAccessor { }
    public interface IResourceLocationGet : IResourceLocationAccessor
    {
        public IEnumerable<Unit<TUnit>> Get<TResource, TUnit>(EffectInput data)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType;
    }
    public interface IResourceLocationSet : IResourceLocationAccessor
    {
        public void Set<TResource, TUnit>(EffectInput data, IEnumerable<Unit<TUnit>> values)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType;
    }
}
namespace TagFighter.Optics
{
    using System;
    using CareBoo.Serially;
    using Resources;
    public interface ILens<Whole, Part>
    {
        Part Get(Whole whole);
        Whole Set(Part part, Whole whole);
    }
    public readonly struct Lens<TWhole, TPart>
    {
        public readonly Func<TWhole, TPart> Get;
        public readonly Func<TWhole, TPart, TWhole> Set;
        public Lens(Func<TWhole, TPart> getter, Func<TWhole, TPart, TWhole> setter) {
            Get = getter ?? throw new ArgumentNullException(nameof(getter));
            Set = setter ?? throw new ArgumentNullException(nameof(setter));
        }
    }
    public static class LensExtensions
    {
        public static Lens<TWhole, TPart> Lens<TWhole, TPart>(
            this TWhole _,
            Func<TWhole, TPart> getter, Func<TWhole, TPart, TWhole> setter) =>
            new Lens<TWhole, TPart>(getter, setter);
        //public static TWhole Update<TWhole, TPart>(
        //    this Lens<TWhole, TPart> lens,
        //    TWhole whole, Func<TPart, TPart> update) =>
        //    lens.Set(whole, update(lens.Get(whole)));
        public static Lens<TWhole, TSubPart> Compose<TWhole, TPart, TSubPart>(
            this Lens<TWhole, TPart> parent, Lens<TPart, TSubPart> child) =>
            new Lens<TWhole, TSubPart>(
              whole => child.Get(parent.Get(whole)),
              (whole, part) => parent.Set(whole, child.Set(parent.Get(whole), part)));
    }
    public interface IResourceStatLensCreator
    {
        public Lens<TResource, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType;
    }
    [ProvideSourceInfo]
    [Serializable]
    public class ResourceCurrentLensCreator : IResourceStatLensCreator
    {
        public Lens<TResource, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            return new Lens<TResource, Unit<TUnitType>>(r => r.GetCurrent(), (r, u) => r);
        }
    }
    [ProvideSourceInfo]
    [Serializable]
    public class ResourceCapacityLensCreator : IResourceStatLensCreator
    {
        public Lens<TResource, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType {
            return new Lens<TResource, Unit<TUnitType>>(r => r.GetCapacity(), (r, u) => r);
        }
    }
}

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

B:BD[9.780121071] → [2.89944:90023]

  m_LocalRotation: {x: 0.22914572, y: -0.07070914, z: 0.01669216, w: 0.970677}

[9.780121071]

[10.33888019]

  m_LocalRotation: {x: 0.22914575, y: -0.0707091, z: 0.01669215, w: 0.970677}

Replacement in Assets/Scenes/SampleScene.unity at line 7173 [9.780110080]

B:BD[2.91014] → [2.91014:91154]

  _actionTesterWeaver: {fileID: 1829046329}
  _actionTesterTransform1: {fileID: 1683100414}
  _actionTesterTransform2: {fileID: 1190570253}

[2.91014]

[9.780146030]

  opticsTester:
    _transform: {fileID: 1683100414}
    _accessor:
      rid: 5865794024626716692
  actionsTester:
    _weaver: {fileID: 1829046329}
    _transform1: {fileID: 1683100414}
    _transform2: {fileID: 1190570253}
  references:
    version: 2
    RefIds:
    - rid: 5865794024626716692
      type: {class: PawnAccessor, ns: Testing.Optics, asm: Assembly-CSharp}
      data:
        ResourceLensVisitor:
          rid: 5865794024626716699
        ResourceLensCreator:
          rid: 5865794024626716698
    - rid: 5865794024626716698
      type: {class: ResourceCurrentLensCreator, ns: TagFighter.Optics, asm: Assembly-CSharp}
    - rid: 5865794024626716699
      type: {class: RedTagVisitor, ns: Testing.Optics, asm: Assembly-CSharp}

Replacement in Assets/Scenes/SampleScene.unity at line 7925 [9.780110080]
B:BD[9.780161886] → [5.40620:40657]
```
    m_SensorSize: {x: 2.14826, y: 1}
```
[9.780161886]
[9.780161925]
```
    m_SensorSize: {x: 2.1573374, y: 1}
```

Replacement in Assets/Scenes/SampleScene.unity at line 7941 [9.780110080]

B:BD[9.780162310] → [2.93029:93108]

  m_LocalRotation: {x: 0.22914572, y: -0.07070914, z: 0.01669216, w: 0.970677}

[9.780162310]

[10.33918016]

  m_LocalRotation: {x: 0.22914575, y: -0.0707091, z: 0.01669215, w: 0.970677}