itai.sharim/TagFight - Change 33YYBTSQFQMGO5RYBAFYGX3L4N7YS4DT4CEJKB6ZVYCIIZGDQD2QC

fix RegistryKey and foreach on context. Add lens tester for context. Currently can't be run as Context is dependent on MonoBehavior

Created by itai.sharim on August 2, 2023

33YYBTSQFQMGO5RYBAFYGX3L4N7YS4DT4CEJKB6ZVYCIIZGDQD2QC

Dependencies

In channels

main

Change contents

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

B:BD[3.286] → [4.353:8545]

B:BD[4.8545] → [2.353:16737]

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 Mono.Cecil;
    using System;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Reflection.Emit;
    using TagFighter.Effects;
    using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
    using TagFighter.Optics;
    using TagFighter.Resources;
    using TMPro;
    using Unity.VisualScripting;
    using static Unity.VisualScripting.Metadata;
    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, ShowSerializeReferen
ce]
        public IResourceStatLensCreator ResourceLensCreator; // Current/Capacity
        [TypeFilter(derivedFrom: typeof(IWatchableResource))]
        [SerializeField]
        public CareBoo.Serially.SerializableType Watch;
        public Lens<Transform, int> Create() {
            Type TResource = Watch.Type;
            var TUnitInner = TResource.BaseType.GetGenericArguments()[0];
            var TUnit = typeof(Unit<>).MakeGenericType(TUnitInner);
            MethodInfo mi = typeof(PawnAccessor).GetMethod($"CreateSpecific");
            MethodInfo miConstructed = mi.MakeGenericMethod(TResource, TUnitInner);
            var lens = miConstructed.Invoke(this, null);
            return (Lens<Transform, int>)lens;
            //Debug.Log($"{TResource}, {TUnitInner}, {TUnit}, {miConstructed}");
            //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;
        //object BuildResourceLens(Type resourceType) {
        //    var lensType = typeof(Lens<,>).MakeGenericType(typeof(Transform), resourceType);
        //    var lensCtor = lensType.GetConstructors().First();
        //    ParameterExpression t = Expression.Parameter(typeof(Transform), "t");
        //    Expression call = Expression.Call(t, "GetComponent", new Type[] { resourceType });
        //    var lambda1 = Expression.Lambda(call, new ParameterExpression[] { t }).Compile();
        //    ParameterExpression r = Expression.Parameter(resourceType, "r");
        //    LabelTarget returnTarget = Expression.Label(typeof(Transform));
        //    var returnExpression = Expression.Return(returnTarget, t, typeof(Transform));
        //    LabelExpression returnLabel = Expression.Label(returnTarget, t);
        //    var block = Expression.Block(returnExpression, returnLabel);
        //    var lambda2 = Expression.Lambda(block, new ParameterExpression[] { t, r, }).Compile();
        //    var resourceLens = lensCtor.Invoke(new object[] { lambda1, lambda2 });
        //    return resourceLens;
        //}
        //object BuildStatLens(Type resourceType, Type unitType) {
        //    var lensType = typeof(Lens<,>).MakeGenericType(resourceType, unitType);
        //    var lensCtor = lensType.GetConstructors().First();
        //    ParameterExpression r = Expression.Parameter(resourceType, "r");
        //    Expression call = Expression.Call(r, "GetCurrent", Type.EmptyTypes);
        //    var lambda1 = Expression.Lambda(call, new ParameterExpression[] { r }).Compile();
        //    ParameterExpression u = Expression.Parameter(unitType, "u");
        //    LabelTarget returnTarget = Expression.Label(resourceType);
        //    var returnExpression = Expression.Return(returnTarget, r, resourceType);
        //    LabelExpression returnLabel = Expression.Label(returnTarget, r);
        //    var block = Expression.Block(returnExpression, returnLabel);
        //    var lambda2 = Expression.Lambda(block, new ParameterExpression[] { r, u }).Compile();
        //    var statLens = lensCtor.Invoke(new object[] { lambda1, lambda2 });
        //    return statLens;
        //}
        //object BuildValueLens(Type unitType) {
        //    var lensType = typeof(Lens<,>).MakeGenericType(unitType, typeof(int));
        //    var lensCtor = lensType.GetConstructors().First();
        //    ParameterExpression u = Expression.Parameter(unitType, "u");
        //    Expression call = Expression.Call(u, "AsPrimitive", Type.EmptyTypes);
        //    var lambda1 = Expression.Lambda(call, new ParameterExpression[] { u }).Compile();
        //    ParameterExpression v = Expression.Parameter(typeof(int), "v");
        //    Expression assignValueExpression = Expression.Assign(u, Expression.ConvertChecked(v, unitType));
        //    LabelTarget returnTarget = Expression.Label(unitType);
        //    var returnExpression = Expression.Return(returnTarget, u, unitType);
        //    LabelExpression returnLabel = Expression.Label(returnTarget, u);
        //    var block = Expression.Block(assignValueExpression, returnExpression, returnLabel);
        //    var lambda2 = Expression.Lambda(block, new ParameterExpression[] { u, v }).Compile();
        //    var valueLens = lensCtor.Invoke(new object[] { lambda1, lambda2 });
        //    return valueLens;
        //}
        //object ComposeDynamicLens(object parent, object child, Type TWhole, Type TPart) {
        //    ParameterExpression whole = Expression.Parameter(TWhole, "whole");
        //    var parentGet = Expression.Call(Expression.Constant(parent), "Get", Type.EmptyTypes, whole);
        //    var childGet = Expression.Call(Expression.Constant(child), "Get", Type.EmptyTypes, parentGet);
        //    var lambda1 = Expression.Lambda(childGet, new ParameterExpression[] { whole }).Compile();
        //    //(whole, part) => parent.Set(whole, child.Set(parent.Get(whole), part)));
        //    ParameterExpression part = Expression.Parameter(TPart, "part");
        //    var childSet = Expression.Call(Expression.Constant(child), "Set", Type.EmptyTypes, parentGet, part);
        //    var parentSet = Expression.Call(Expression.Constant(parent), "Set", Type.EmptyTypes, whole, childSet);
        //    var lambda2 = Expression.Lambda(parentSet, new ParameterExpression[] { whole, part }).Compile();
        //    var composedLensType = typeof(Lens<,>).MakeGenericType(TWhole, TPart);
        //    var lensCtor = composedLensType.GetConstructors().First();
        //    var composedLens = lensCtor.Invoke(new object[] { lambda1, lambda2 });
        //    return composedLens;
        //}
        Lens<Transform, int> CreateDynamicResourceLens(Type TResource, Type TUnit) {
            var lensType = typeof(Lens<,>).MakeGenericType(typeof(Transform), typeof(int));
            var lensCtor = lensType.GetConstructors().First();
            ParameterExpression t = Expression.Parameter(typeof(Transform), "t");
            Expression getResource = Expression.Call(t, "GetComponent", new Type[] { TResource });
            Expression getCurrent = Expression.Call(getResource, "GetCurrent", Type.EmptyTypes);
            Expression asPrimitive = Expression.Call(getCurrent, "AsPrimitive", Type.EmptyTypes);
            var getterLambda = Expression.Lambda(asPrimitive, new ParameterExpression[] { t }).Compile();
            ParameterExpression v = Expression.Parameter(typeof(int), "v");
            //Expression assignValueExpression = Expression.Assign(getCurrent, Expression.ConvertChecked(v, TUnit));
            LabelTarget returnTarget = Expression.Label(typeof(Transform));
            var returnExpression = Expression.Return(returnTarget, t, typeof(Transform));
            LabelExpression returnLabel = Expression.Label(returnTarget, t);
            var block = Expression.Block(
                //assignValueExpression, 
                returnExpression,
                returnLabel
            );
            var setterLambda = Expression.Lambda(block, new ParameterExpression[] { t, v }).Compile();
            var resourceLens = lensCtor.Invoke(new object[] { getterLambda, setterLambda });
            return (Lens<Transform, int>)resourceLens;
        }
        public void TestAll() {
            var TResource = typeof(GreenTag);
            var TUnitInner = TResource.BaseType.GetGenericArguments()[0];
            var TUnit = typeof(Unit<>).MakeGenericType(TUnitInner);
            //var resource = new Lens<Transform, GreenTag>(t => t.GetComponent<GreenTag>(), (t, r) => t);
            //var resource = (Lens<Transform, GreenTag>)BuildResourceLens(TResource);
            //var statLens = new Lens<GreenTag, Unit<GreenTagUnit>>(r => r.GetCurrent(), (r, u) => r);
            //var statLens = (Lens<GreenTag, Unit<GreenTagUnit>>)BuildStatLens(TResource, TUnit);
            //var valueLens = new Lens<Unit<GreenTagUnit>, int>(u => u.AsPrimitive(), (u, v) => u = (Unit<GreenTagUnit>)v);
            //var valueLens = (Lens<Unit<GreenTagUnit>, int>)BuildValueLens(TUnit);
            //var lens = resource.Compose(statLens).Compose(valueLens);
            //var lens = ComposeDynamicLens(resource, statLens, valueLens, typeof(GreenTag), typeof(Unit<GreenTagUnit>));
            //var lens = (Lens<Transform, int>)ComposeDynamicLens(ComposeDynamicLens(resource, statLens, typeof(Transform), TUnit), valueLens, typeof(Transform), typeof(int));
            //var lens = CreateDynamicResourceLens(TResource, TUnit);
            var lens = _accessor.Create();
            Debug.Log(lens.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>");
            }
        }
        public void TestMoveToActionConcreteEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var action1 = new MoveToAction(_weaver, _transform1.position);
            var 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>");
            }
        }
        public void TestMoveToActionInterfaceEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new MoveToAction(_weaver, _transform1.position);
            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>");
            }
        }
    }
}
namespace Testing.TimeDialation
{
    public class TimeDialationTester
    {
        EventAggregator _eventAggregator;
        public TimeDialationTester(EventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;

[3.286]

[2.16737]

using System;
using System.Collections;
using TagFighter;
using TagFighter.Events;
using TagFighter.Resources;
using TagFighter.Testing.Optics;
using Testing.Actions;
using Testing.Line;
using Testing.TimeDialation;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
namespace TagFighter.Testing
{
    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("TestPawn", "TestPawnOptics")]
        [ContextMenuItem("TestContext", "TestContextOptics")]
        [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 TestPawnOptics() {
            opticsTester.TestPawn();
        }
        void TestContextOptics() {
            opticsTester.TestContext();
        }
    }
}
namespace TagFighter.Testing.Optics
{
    using CareBoo.Serially;
    using System;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Reflection.Emit;
    using TagFighter.Effects;
    using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
    using TagFighter.Optics;
    using TagFighter.Resources;
    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 IResourceStatLensCreator ResourceLensCreator; // Current/Capacity
        [TypeFilter(derivedFrom: typeof(Resource<>))]
        [SerializeField]
        public SerializableType Resource;
        public Lens<Transform, int> Create() {
            var createSpecificLensMethod = typeof(PawnAccessor).GetMethod(nameof(CreateSpecific)).
                                MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0]);
            var lens = createSpecificLensMethod.Invoke(this, null);
            return (Lens<Transform, int>)lens;
        }
        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;
    }
    [Serializable]
    public class ContextAccessor : IContextAccessor
    {
        // Register
        [SerializeReference, ShowSerializeReference]
        public IRegisterTypeLensCreator RegisterTypeLensCreator;
        [TypeFilter(derivedFrom: typeof(Resource<>))]
        [SerializeField]
        public SerializableType Resource;
        public Lens<EffectContext, int> Create() {
            var createSpecificLensMethod = typeof(ContextAccessor).GetMethod(nameof(CreateSpecific)).
                                MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0]);
            var lens = createSpecificLensMethod.Invoke(this, null);
            return (Lens<EffectContext, int>)lens;
        }
        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 IRegisterTypeLensCreator
    {
        public Lens<EffectContext, Unit<TUnitType>> Create<TResource, TUnitType>()
            where TResource : Resource<TUnitType>
            where TUnitType : IUnitType;
    }
    [Serializable]
    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;
        [SerializeReference, ShowSerializeReference] IContextAccessor _contextAccessor;
        Lens<Transform, int> CreateDynamicResourceLens(Type TResource, Type TUnit) {
            var lensType = typeof(Lens<,>).MakeGenericType(typeof(Transform), typeof(int));
            var lensCtor = lensType.GetConstructors().First();
            ParameterExpression t = Expression.Parameter(typeof(Transform), "t");
            Expression getResource = Expression.Call(t, "GetComponent", new Type[] { TResource });
            Expression getCurrent = Expression.Call(getResource, "GetCurrent", Type.EmptyTypes);
            Expression asPrimitive = Expression.Call(getCurrent, "AsPrimitive", Type.EmptyTypes);
            var getterLambda = Expression.Lambda(asPrimitive, new ParameterExpression[] { t }).Compile();
            ParameterExpression v = Expression.Parameter(typeof(int), "v");
            //Expression assignValueExpression = Expression.Assign(getCurrent, Expression.ConvertChecked(v, TUnit));
            LabelTarget returnTarget = Expression.Label(typeof(Transform));
            var returnExpression = Expression.Return(returnTarget, t, typeof(Transform));
            LabelExpression returnLabel = Expression.Label(returnTarget, t);
            var block = Expression.Block(
                //assignValueExpression, 
                returnExpression,
                returnLabel
            );
            var setterLambda = Expression.Lambda(block, new ParameterExpression[] { t, v }).Compile();
            var resourceLens = lensCtor.Invoke(new object[] { getterLambda, setterLambda });
            return (Lens<Transform, int>)resourceLens;
        }
        public void TestAll() {
        }
        public void TestPawn() {
            var lens = _accessor.Create();
            Debug.Log(lens.Get(_transform));
        }
        public void TestContext() {
            EffectContext effectContext = new EffectContext();
            var lens = _contextAccessor.Create();
            lens.Set(effectContext, 5);
            effectContext.SetResource<RedTag, RedTagUnit, Current>((Unit<RedTagUnit>)1);
            foreach (var a in effectContext.GetAllResourcesInRegister<Current>()) {
                Debug.Log($"In foreach {a}");
            }
            Debug.Log($"{lens.Get(effectContext)}");
        }
    }
}
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>");
            }
        }
        public void TestMoveToActionConcreteEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var action1 = new MoveToAction(_weaver, _transform1.position);
            var 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>");
            }
        }
        public void TestMoveToActionInterfaceEqual() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            IAction action1 = new MoveToAction(_weaver, _transform1.position);
            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>");
            }
        }
    }
}
namespace Testing.TimeDialation
{
    public class TimeDialationTester
    {
        EventAggregator _eventAggregator;
        public TimeDialationTester(EventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;

Replacement in Assets/Scripts/Combat/Runes/Effects/EffectContext.cs at line 1 [5.6210]

B:BD[5.6210] → [6.44688:48482]

using System;
using System.Collections.Generic;
using System.Linq;
using Mono.Cecil;
using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
using TagFighter.Resources;
using Unity.VisualScripting.FullSerializer.Internal;
using UnityEngine;
namespace TagFighter.Effects
{
    public class ReleaseMultiplier
    {
        public Type MatchingAoe { get; set; }
        public float MatchingAoeReleaseMultiplier { get; set; } = 1f;
        public float NonMatchingAoeReleaseMultiplier { get; set; } = 1f;
    }
    public class RegistryKey
    {
        public Type ContextRegisterType;
        public Type ResourceType;
        public RegistryKey(Type contextRegisterType, Type resourceType) {
            ContextRegisterType = contextRegisterType;
            ResourceType = resourceType;
        }
    }
    public class EffectContext
    {
        Dictionary<RegistryKey, IUnit> _resourceRegistry = new();
        public Transform Caster { get; set; }
        public Transform EffectLocation { get; set; }
        public IAreaOfEffect AreaOfEffect;
        public List<IDelayedEffect> EffectsToTrigger { get; set; } = new();
        public IEffectSystem EffectSystem { get; private set; }
        public ReleaseMultiplier ReleaseMultiplier { get; set; }
        public EffectContext() {
            EffectSystem = SystemsHandler.EffectSystem;
            ReleaseMultiplier = new();
        }
        public Unit<TUnit> GetResource<TResource, TUnit, TContextRegister>()
            where TResource : Resource<TUnit>
            where TUnit : IUnitType
            where TContextRegister : IContextRegister {
            var key = new RegistryKey(typeof(TContextRegister), typeof(TResource));
            var value = (Unit<TUnit>)_resourceRegistry.GetValueOrDefault(key, (Unit<TUnit>)0);
            Debug.Log($"{nameof(GetResource)} ({typeof(TResource).Name},{typeof(TContextRegister).Name}) = {value}");
            return value;
        }
        public Unit<TUnit> SetResource<TResource, TUnit, TContextRegister>(Unit<TUnit> value)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType
            where TContextRegister : IContextRegister {
            var key = new RegistryKey(typeof(TContextRegister), typeof(TResource));
            var newValue = (Unit<TUnit>)(_resourceRegistry[key] = value);
            Debug.Log($"{nameof(SetResource)} ({typeof(TResource).Name},{typeof(TContextRegister).Name})  = {newValue}");
            return newValue;
        }
        public IEnumerable<(Type, IUnit)> GetAllResourcesInRegister<TContextRegister>() where TContextRegister : IContextRegister {
            Type t = typeof(TContextRegister).BaseType;
            return _resourceRegistry.Where(x => x.Key.ContextRegisterType == t).Select(x => (x.Key.ResourceType, x.Value));
        }
        public IEnumerable<Transform> GetAffectedUnits() {
            if (AreaOfEffect == null) {
                return Enumerable.Empty<Transform>();
            }
            var directionVector = (EffectLocation.position - Caster.position).normalized;
            directionVector.y = 0;
            var direction = Quaternion.LookRotation(directionVector, Vector3.up);
            GameObject tmpGo = new();
            tmpGo.transform.position = EffectLocation.position;
            tmpGo.transform.rotation = direction;
            var affectedUnits = AreaOfEffect.GetAffectedUnits(EffectLocation);
            GameObject.Destroy(tmpGo);
            return affectedUnits;
        }
        void ResetEffects() {
            EffectsToTrigger.Clear();
        }
        public void Reset() {
            ResetEffects();
        }
    }
}

[5.6210]

using System;
using System.Collections.Generic;
using System.Linq;
using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.Effects
{
    public class ReleaseMultiplier
    {
        public Type MatchingAoe { get; set; }
        public float MatchingAoeReleaseMultiplier { get; set; } = 1f;
        public float NonMatchingAoeReleaseMultiplier { get; set; } = 1f;
    }
    public record RegistryKey
    {
        public Type ContextRegisterType;
        public Type ResourceType;
        public RegistryKey(Type contextRegisterType, Type resourceType) {
            ContextRegisterType = contextRegisterType;
            ResourceType = resourceType;
        }
    }
    public class EffectContext
    {
        Dictionary<RegistryKey, IUnit> _resourceRegistry = new();
        public Transform Caster { get; set; }
        public Transform EffectLocation { get; set; }
        public IAreaOfEffect AreaOfEffect;
        public List<IDelayedEffect> EffectsToTrigger { get; set; } = new();
        public IEffectSystem EffectSystem { get; private set; }
        public ReleaseMultiplier ReleaseMultiplier { get; set; }
        public EffectContext() {
            EffectSystem = SystemsHandler.EffectSystem;
            ReleaseMultiplier = new();
        }
        public Unit<TUnit> GetResource<TResource, TUnit, TContextRegister>()
            where TResource : Resource<TUnit>
            where TUnit : IUnitType
            where TContextRegister : IContextRegister {
            var key = new RegistryKey(typeof(TContextRegister), typeof(TResource));
            var value = (Unit<TUnit>)_resourceRegistry.GetValueOrDefault(key, (Unit<TUnit>)0);
            Debug.Log($"{nameof(GetResource)} ({typeof(TResource).Name},{typeof(TContextRegister).Name}) = {value}");
            return value;
        }
        public Unit<TUnit> SetResource<TResource, TUnit, TContextRegister>(Unit<TUnit> value)
            where TResource : Resource<TUnit>
            where TUnit : IUnitType
            where TContextRegister : IContextRegister {
            var key = new RegistryKey(typeof(TContextRegister), typeof(TResource));
            var newValue = (Unit<TUnit>)(_resourceRegistry[key] = value);
            Debug.Log($"{nameof(SetResource)} ({typeof(TResource).Name},{typeof(TContextRegister).Name})  = {newValue}");
            return newValue;
        }
        public IEnumerable<(Type, IUnit)> GetAllResourcesInRegister<TContextRegister>() where TContextRegister : IContextRegister {
            return _resourceRegistry.Where(x => x.Key.ContextRegisterType == typeof(TContextRegister)).Select(x => (x.Key.ResourceType, x.Value));
        }
        public IEnumerable<Transform> GetAffectedUnits() {
            if (AreaOfEffect == null) {
                return Enumerable.Empty<Transform>();
            }
            var directionVector = (EffectLocation.position - Caster.position).normalized;
            directionVector.y = 0;
            var direction = Quaternion.LookRotation(directionVector, Vector3.up);
            GameObject tmpGo = new();
            tmpGo.transform.position = EffectLocation.position;
            tmpGo.transform.rotation = direction;
            var affectedUnits = AreaOfEffect.GetAffectedUnits(EffectLocation);
            GameObject.Destroy(tmpGo);
            return affectedUnits;
        }
        void ResetEffects() {
            EffectsToTrigger.Clear();
        }
        public void Reset() {
            ResetEffects();
        }
    }
}

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

B:BD[7.780121071] → [2.17806:17887]

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

[7.780121071]

[8.33888019]

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

Replacement in Assets/Scenes/SampleScene.unity at line 7176 [7.780110080]

B:BD[9.22806] → [2.17888:17919]

      rid: 5865794024626716700

[9.22806]

[9.22837]

      rid: 5865794024626716703
    _contextAccessor:
      rid: 5865794024626716705

Replacement in Assets/Scenes/SampleScene.unity at line 7186 [7.780110080]

B:BD[9.23005] → [2.17920:17951]

∅:D[2.17951] → [9.23036:23112]

B:BD[9.23036] → [9.23036:23112]

    - rid: 5865794024626716700
      type: {class: PawnAccessor, ns: Testing.Optics, asm: Assembly-CSharp}

[9.23005]

[9.23112]

    - rid: 5865794024626716703
      type: {class: PawnAccessor, ns: TagFighter.Testing.Optics, asm: Assembly-CSharp}

Deletion in Assets/Scenes/SampleScene.unity at line 7189 [7.780110080]
B:BD[9.23124] → [9.23124:23153]
B:BD[9.23153] → [2.17952:17987]
```
        ResourceLensVisitor:
          rid: 5865794024626716702
```

Replacement in Assets/Scenes/SampleScene.unity at line 7190 [7.780110080]

B:BD[9.23217] → [2.17988:18038]

          rid: 5865794024626716701
        Watch:

[9.23217]

[2.18038]

          rid: 5865794024626716704
        Resource:

Replacement in Assets/Scenes/SampleScene.unity at line 7193 [7.780110080]
B:BD[2.18093] → [2.18093:18124]
```
    - rid: 5865794024626716701
```
[2.18093]
[9.23283]
```
    - rid: 5865794024626716704
```

Replacement in Assets/Scenes/SampleScene.unity at line 7195 [7.780110080]

B:BD[9.23376] → [2.18125:18234]

    - rid: 5865794024626716702
      type: {class: BlueTagVisitor, ns: Testing.Optics, asm: Assembly-CSharp}

[9.23376]

[7.780146030]

    - rid: 5865794024626716705
      type: {class: ContextAccessor, ns: TagFighter.Testing.Optics, asm: Assembly-CSharp}
      data:
        RegisterTypeLensCreator:
          rid: 5865794024626716706
        Resource:
          typeId: aecc1739-a0df-4013-b430-22d2eb13f0ff
    - rid: 5865794024626716706
      type: {class: CurrentRegisterTypeLensCreator, ns: TagFighter.Testing.Optics,
        asm: Assembly-CSharp}

Replacement in Assets/Scenes/SampleScene.unity at line 7951 [7.780110080]

B:BD[7.780162310] → [2.18235:18316]

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

[7.780162310]

[8.33918016]

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