defaultReferences: []

  defaultReferences:
  - _moveSetRules: {fileID: 11400000, guid: 30832b41ea076364dbf3e816c7358dd6, type: 2}

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

using UnityEngine;
namespace TagFighter.UnitControl
{
    [CreateAssetMenu(fileName = "NewUnitControllerType", menuName = "Game/Control/UnitControllerType")]
    public class UnitControllerType : ScriptableObject { }
}

fileFormatVersion: 2
guid: 7091ffc98d65ebf4a8279f8c34e4369b
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences:
  - ControlledBy: {instanceID: 0}
  - _eventAggregator: {fileID: 11400000, guid: 7674cb78dbff8d447b6c39984750a2da, type: 2}
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

using System;
using System.Collections;
using System.Collections.Generic;
using TagFighter.Events;
using TagFighter.UnitControl;
using UnityEngine;
namespace TagFighter.Events
{
    public class UnitControllerTargetStartedEventArgs : EventArgs
    {
        public Transform UnitTransform { get; }
        public UnitControllerType ControlledBy { get; }
        public UnitControllerTargetStartedEventArgs(Transform unitTransform, UnitControllerType controlledBy) {
            UnitTransform = unitTransform;
            ControlledBy = controlledBy;
        }
    }
}
namespace TagFighter.UnitControl
{
    public class UnitControllerTarget : MonoBehaviour
    {
        public UnitControllerType ControlledBy;
        [SerializeField] EventAggregator _eventAggregator;
        protected void Start() {
            _eventAggregator.OnUnitControllerStarted(this, new(transform, ControlledBy));
        }
    }
}

using System;
using TagFighter.Effects;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter
{
    public class WeaveAction : IAction
    {
        FollowAction _followAction;
        Transform _target;
        Weaver _weaver;
        RuneWeavingContainer _runeWeaving;
        Resources.Range _range;
        bool _startedWeaving = false;
        static State s_resetState = new(true, 1f, false, default);
        bool _disposed = false;
        int _lastRange;
        EffectContext _context;
        ITimeContextContainer _timeContextContainer;
        public WeaveAction(Weaver unit, RuneWeavingContainer runeWeaving, Transform target, Resources.Range range) {
            if (range is null) {
                throw new ArgumentNullException("range");
            }
            _target = target;
            _range = range;
            _weaver = unit;
            _runeWeaving = runeWeaving;
            var currentRange = _range.GetCurrent();
            _lastRange = currentRange.AsPrimitive();
            _followAction = new(_weaver, _target, currentRange.ToMeter());
            _range.ResourceChanged += OnResourceChanged;
            _context = new EffectContext() {
                EffectLocation = target,
                Caster = unit.transform
            };
        }
        void OnResourceChanged(object sender, ResourceChangeArgs e) {
            if (_lastRange != e.Current) {
                _followAction.Dispose();
                _followAction = new(_weaver, _target, _range.GetCurrent().ToMeter());
                _lastRange = e.Current;
            }
        }
        public IActionState Advance() {
            var stateToReturn = _followAction.Advance();
            if (IsInAttackRange()) {
                if (_startedWeaving == false) {
                    Debug.Log("Target got in range, weaving");
                    _timeContextContainer = _runeWeaving.RuneWeaving.CreateTimeContexts();
                }
                _startedWeaving = true;
                var isAdvanced = _runeWeaving.RuneWeaving.Advance(_timeContextContainer, _context, Time.deltaTime);
                stateToReturn = new State(isAdvanced, CompletionStatus(), false, _runeWeaving.RuneWeaving.GetCurrentMove(_timeContextContainer));
            }
            else {
                if (_startedWeaving) {
                    Debug.Log("Target escaped");
                    stateToReturn = new State(false, CompletionStatus(), stateToReturn.IsMoving, _runeWeaving.RuneWeaving.GetCurrentMove(_timeContextContainer));
                }
            }
            return stateToReturn;
        }
        IActionState Cancel() {
            _timeContextContainer = null;
            return s_resetState;
        }
        public float CompletionStatus() => _runeWeaving.RuneWeaving.CompletionStatus(_timeContextContainer);
        public override string ToString() {
            return $"{_runeWeaving.WeaveName} -> {_target.name}";
        }
        bool IsInAttackRange() {
            // Incorrect in case there are hills. should calc range from feet.
            Vector3 source = new(_weaver.transform.position.x, 0, _weaver.transform.position.z);
            Vector3 target = new(_target.position.x, 0, _target.position.z);
            return Vector3.Distance(source, target) <= _range.GetCurrent().ToMeter();
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    Cancel();
                    _followAction.Dispose();
                    _followAction = null;
                    _range.ResourceChanged -= OnResourceChanged;
                    _range = null;
                    _runeWeaving = null;
                    _target = null;
                    _weaver = null;
                }
                _disposed = true;
            }
        }
        public readonly struct State : IActionState
        {
            public bool IsAdvanced { get; }
            public float CompletionStatus { get; }
            public bool IsMoving { get; }
            public CombatMove Move { get; }
            public State(bool isAdvanced, float completionStatus, bool isMoving, CombatMove move) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = isMoving;
                Move = move;
            }
        }
    }
}

using System;
using TagFighter.Effects;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter
{
    public class WeaveAction : IAction
    {
        FollowAction _followAction;
        Transform _target;
        Weaver _weaver;
        RuneWeavingContainer _runeWeaving;
        Resources.Range _range;
        bool _startedWeaving = false;
        static State s_resetState = new(true, 1f, false, default);
        bool _disposed = false;
        int _lastRange;
        EffectContext _context;
        ITimeContextContainer _timeContextContainer;
        public WeaveAction(Weaver unit, RuneWeavingContainer runeWeaving, Transform target, Resources.Range range) {
            if (range is null) {
                throw new ArgumentNullException("range");
            }
            _target = target;
            _range = range;
            _weaver = unit;
            _runeWeaving = runeWeaving;
            var currentRange = _range.GetCurrent();
            _lastRange = currentRange.AsPrimitive();
            _followAction = new(_weaver, _target, currentRange.ToMeter());
            _range.ResourceChanged += OnResourceChanged;
            _context = new EffectContext() {
                EffectLocation = target,
                Caster = unit.transform
            };
        }
        void OnResourceChanged(object sender, ResourceChangeArgs e) {
            if (_lastRange != e.Current) {
                _followAction.Dispose();
                _followAction = new(_weaver, _target, _range.GetCurrent().ToMeter());
                _lastRange = e.Current;
            }
        }
        public IActionState Advance() {
            var stateToReturn = _followAction.Advance();
            if (IsInAttackRange()) {
                if (_startedWeaving == false) {
                    Debug.Log("Target got in range, weaving");
                    _timeContextContainer = _runeWeaving.RuneWeaving.CreateTimeContexts();
                }
                _startedWeaving = true;
                var isAdvanced = _runeWeaving.RuneWeaving.Advance(_timeContextContainer, _context, Time.deltaTime);
                stateToReturn = new State(isAdvanced, CompletionStatus(), false, _runeWeaving.RuneWeaving.GetCurrentMove(_timeContextContainer));
            }
            else {
                if (_startedWeaving) {
                    Debug.Log("Target escaped");
                    stateToReturn = new State(false, CompletionStatus(), stateToReturn.IsMoving, _runeWeaving.RuneWeaving.GetCurrentMove(_timeContextContainer));
                }
            }
            return stateToReturn;
        }
        IActionState Cancel() {
            _timeContextContainer = null;
            return s_resetState;
        }
        public float CompletionStatus() => _runeWeaving.RuneWeaving.CompletionStatus(_timeContextContainer);
        public bool IsSimilarAction(IActionRead action) {
            if (action is not WeaveAction other) {
                return false;
            }
            return other != null && _target == other._target && _weaver == other._weaver && _runeWeaving.WeaveName == other._runeWeaving.WeaveName;
        }
        public override string ToString() {
            return $"{_runeWeaving.WeaveName} -> {_target.name}";
        }
        bool IsInAttackRange() {
            // Incorrect in case there are hills. should calc range from feet.
            Vector3 source = new(_weaver.transform.position.x, 0, _weaver.transform.position.z);
            Vector3 target = new(_target.position.x, 0, _target.position.z);
            return Vector3.Distance(source, target) <= _range.GetCurrent().ToMeter();
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    Cancel();
                    _followAction.Dispose();
                    _followAction = null;
                    _range.ResourceChanged -= OnResourceChanged;
                    _range = null;
                    _runeWeaving = null;
                    _target = null;
                    _weaver = null;
                }
                _disposed = true;
            }
        }
        public readonly struct State : IActionState
        {
            public bool IsAdvanced { get; }
            public float CompletionStatus { get; }
            public bool IsMoving { get; }
            public CombatMove Move { get; }
            public State(bool isAdvanced, float completionStatus, bool isMoving, CombatMove move) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = isMoving;
                Move = move;
            }
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.AI;
namespace TagFighter
{
    public class MoveToAction : IAction
    {
        Vector3 _lastTargetPosition;
        NavMeshAgent _agent;
        float _originalStoppingDistance;
        float _desiredStoppingDistance;
        bool _isFirstAdvance = true;
        static State s_resetState = new(false, 0f, false);
        bool _disposed = false;
        public MoveToAction(Weaver unit, Vector3 target) {
            if (unit == null) {
                throw new ArgumentNullException("unit");
            }
            if (unit.TryGetComponent(out _agent) == false) {
                throw new ArgumentException("Missing NavMeshAgent", "unit");
            }
            _lastTargetPosition = target;
            _desiredStoppingDistance = _agent.stoppingDistance;
        }
        public MoveToAction(Weaver unit, Vector3 target, float stoppingDistance) {
            if (unit == null) {
                throw new ArgumentNullException("unit");
            }
            if (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }
            if (unit.TryGetComponent(out _agent) == false) {
                throw new ArgumentException("Missing NavMeshAgent", "unit");
            }
            _lastTargetPosition = target;
            _desiredStoppingDistance = stoppingDistance;
        }
        public bool SetDestination(Vector3 target) {
            _lastTargetPosition = target;
            return _agent.SetDestination(target);
        }
        public void SetStoppingDistance(float stoppingDistance) {
            if (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }
            _desiredStoppingDistance = stoppingDistance;
            _agent.stoppingDistance = _desiredStoppingDistance;
        }
        public IActionState Advance() {
            if (_isFirstAdvance) {
                _originalStoppingDistance = _agent.stoppingDistance;
                _agent.stoppingDistance = _desiredStoppingDistance;
                _agent.isStopped = false;
                _agent.SetDestination(_lastTargetPosition);
                _isFirstAdvance = false;
            }
            var isAdvanced = !_agent.hasPath || _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;
            return new State(isAdvanced, CompletionStatus(), isAdvanced);
        }
        IActionState Cancel() {
            _agent.isStopped = true;
            _agent.stoppingDistance = _originalStoppingDistance;
            _agent.ResetPath();
            _isFirstAdvance = true;
            return s_resetState;
        }
        public float CompletionStatus() {
            return 0;
        }
        public override string ToString() {
            return $"Move -> {_lastTargetPosition}";
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    Cancel();
                    _agent = null;
                }
                _disposed = true;
            }
        }
        public readonly struct State : IActionState
        {
            public bool IsAdvanced { get; }
            public float CompletionStatus { get; }
            public bool IsMoving { get; }
            public State(bool isAdvanced, float completionStatus, bool isMoving) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = isMoving;
            }
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.AI;
namespace TagFighter
{
    public class MoveToAction : IAction
    {
        Vector3 _lastTargetPosition;
        NavMeshAgent _agent;
        float _originalStoppingDistance;
        float _desiredStoppingDistance;
        bool _isFirstAdvance = true;
        static State s_resetState = new(false, 0f, false);
        bool _disposed = false;
        public MoveToAction(Weaver unit, Vector3 target) {
            if (unit == null) {
                throw new ArgumentNullException("unit");
            }
            if (unit.TryGetComponent(out _agent) == false) {
                throw new ArgumentException("Missing NavMeshAgent", "unit");
            }
            _lastTargetPosition = target;
            _desiredStoppingDistance = _agent.stoppingDistance;
        }
        public MoveToAction(Weaver unit, Vector3 target, float stoppingDistance) {
            if (unit == null) {
                throw new ArgumentNullException("unit");
            }
            if (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }
            if (unit.TryGetComponent(out _agent) == false) {
                throw new ArgumentException("Missing NavMeshAgent", "unit");
            }
            _lastTargetPosition = target;
            _desiredStoppingDistance = stoppingDistance;
        }
        public bool SetDestination(Vector3 target) {
            _lastTargetPosition = target;
            return _agent.SetDestination(target);
        }
        public void SetStoppingDistance(float stoppingDistance) {
            if (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }
            _desiredStoppingDistance = stoppingDistance;
            _agent.stoppingDistance = _desiredStoppingDistance;
        }
        public IActionState Advance() {
            if (_isFirstAdvance) {
                _originalStoppingDistance = _agent.stoppingDistance;
                _agent.stoppingDistance = _desiredStoppingDistance;
                _agent.isStopped = false;
                _agent.SetDestination(_lastTargetPosition);
                _isFirstAdvance = false;
            }
            var isAdvanced = _agent.hasPath || _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;
            return new State(isAdvanced, CompletionStatus(), isAdvanced);
        }
        IActionState Cancel() {
            _agent.isStopped = true;
            _agent.stoppingDistance = _originalStoppingDistance;
            _agent.ResetPath();
            _isFirstAdvance = true;
            return s_resetState;
        }
        public float CompletionStatus() {
            return 0;
        }
        public bool IsSimilarAction(IActionRead action) {
            if (action is not MoveToAction other) {
                return false;
            }
            return other != null && _agent == other._agent && _lastTargetPosition == other._lastTargetPosition;
        }
        public override string ToString() {
            return $"Move -> {_lastTargetPosition}";
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    Cancel();
                    _agent = null;
                }
                _disposed = true;
            }
        }
        public readonly struct State : IActionState
        {
            public bool IsAdvanced { get; }
            public float CompletionStatus { get; }
            public bool IsMoving { get; }
            public State(bool isAdvanced, float completionStatus, bool isMoving) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = isMoving;
            }
        }
    }
}

using System;
namespace TagFighter
{
    public interface IAction : IDisposable
    {
        public IActionState Advance();
        public float CompletionStatus();
    }
    public interface IActionState
    {
        public bool IsAdvanced { get; }
        public float CompletionStatus { get; }
        public bool IsMoving { get; }
    }
}

using System;
namespace TagFighter
{
    public interface IActionRead
    {
        public float CompletionStatus();
        public bool IsSimilarAction(IActionRead action);
    }
    public interface IAction : IActionRead, IDisposable
    {
        public IActionState Advance();
    }
    public interface IActionState
    {
        public bool IsAdvanced { get; }
        public float CompletionStatus { get; }
        public bool IsMoving { get; }
    }
}

using System;
using UnityEngine;
namespace TagFighter
{
    public class FollowAction : IAction
    {
        MoveToAction _moveAction;
        Transform _target;
        Vector3 _lastTargetPosition;
        bool _disposed = false;
        public FollowAction(Weaver unit, Transform target) {
            _target = target ?? throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition);
        }
        public FollowAction(Weaver unit, Transform target, float stoppingDistance) {
            _target = target ?? throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition, stoppingDistance);
        }
        public void SetStoppingDistance(float stoppingDistance) {
            _moveAction.SetStoppingDistance(stoppingDistance);
        }
        public IActionState Advance() {
            if (_lastTargetPosition != _target.position) {
                _lastTargetPosition = _target.position;
                _moveAction.SetDestination(_lastTargetPosition);
            }
            return _moveAction.Advance();
        }
        public float CompletionStatus() {
            return 0;
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    _moveAction.Dispose();
                    _moveAction = null;
                    _target = null;
                }
                _disposed = true;
            }
        }
        public override string ToString() {
            return $"Follow {_target.name}";
        }
    }
}

using System;
using UnityEngine;
namespace TagFighter
{
    public class FollowAction : IAction
    {
        MoveToAction _moveAction;
        Transform _target;
        Vector3 _lastTargetPosition;
        bool _disposed = false;
        public FollowAction(Weaver unit, Transform target) {
            _target = target != null ? target : throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition);
        }
        public FollowAction(Weaver unit, Transform target, float stoppingDistance) {
            _target = target != null ? target : throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition, stoppingDistance);
        }
        public void SetStoppingDistance(float stoppingDistance) {
            _moveAction.SetStoppingDistance(stoppingDistance);
        }
        public IActionState Advance() {
            if (_lastTargetPosition != _target.position) {
                _lastTargetPosition = _target.position;
                _moveAction.SetDestination(_lastTargetPosition);
            }
            return _moveAction.Advance();
        }
        public float CompletionStatus() {
            return 0;
        }
        public bool IsSimilarAction(IActionRead action) {
            if (action is not FollowAction other) {
                return false;
            }
            return other != null && _target == other._target;
        }
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    _moveAction.Dispose();
                    _moveAction = null;
                    _target = null;
                }
                _disposed = true;
            }
        }
        public override string ToString() {
            return $"Follow {_target.name}";
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace TagFighter.Actions
{
    public class TakeActionEventArgs : EventArgs
    {
        public IActionState ActionState { get; }
        public TakeActionEventArgs(IActionState actionState) {
            ActionState = actionState;
        }
    }
    public class ActionPlan : MonoBehaviour, IEnumerable<IAction>
    {
        public event EventHandler<TakeActionEventArgs> ActionTaken;
        public event EventHandler<UnitActionEventArgs> PlanChanged;
        Line<IAction> _plannedActions = new(capacity: 6);
        protected void OnActionTaken(TakeActionEventArgs e) {
            ActionTaken?.Invoke(this, e);
        }
        protected void OnPlannedActionsChanged(UnitActionEventArgs e) {
            PlanChanged?.Invoke(this, e);
        }
        protected void Update() {
            if (_plannedActions.TryPeek(out var action)) {
                var actionState = action.Advance();
                OnActionTaken(new(actionState));
                if (!actionState.IsAdvanced) {
                    action.Dispose();
                    _plannedActions.TryGetFirstOutOfLine(out var _);
                    OnPlannedActionsChanged(new(transform));
                }
            }
        }
        public bool TryAddActionToPlan(IAction action) {
            var success = false;
            if (_plannedActions.TryWaitInLine(action)) {
                OnPlannedActionsChanged(new(transform));
                success = true;
            }
            return success;
        }
        public void Clear() {
            foreach (var action in _plannedActions) {
                action.Dispose();
            }
            _plannedActions.Clear();
            OnPlannedActionsChanged(new(transform));
        }
        public bool TryRemoveActionFromPlan(int index) {
            var success = false;
            if (_plannedActions.TryRemoveAt(index, out var _)) {
                success = true;
                OnPlannedActionsChanged(new(transform));
            }
            return success;
        }
        public IEnumerator<IAction> GetEnumerator() {
            return _plannedActions.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator() {
            return _plannedActions.GetEnumerator();
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace TagFighter.Actions
{
    public class TakeActionEventArgs : EventArgs
    {
        public IActionState ActionState { get; }
        public TakeActionEventArgs(IActionState actionState) {
            ActionState = actionState;
        }
    }
    public class ActionPlan : MonoBehaviour, IEnumerable<IActionRead>
    {
        public event EventHandler<TakeActionEventArgs> ActionTaken;
        public event EventHandler<UnitActionEventArgs> PlanChanged;
        Line<IAction> _plannedActions = new(capacity: 6);
        protected void OnActionTaken(TakeActionEventArgs e) {
            ActionTaken?.Invoke(this, e);
        }
        protected void OnPlannedActionsChanged(UnitActionEventArgs e) {
            PlanChanged?.Invoke(this, e);
        }
        protected void Update() {
            if (_plannedActions.TryPeek(out var action)) {
                var actionState = action.Advance();
                OnActionTaken(new(actionState));
                if (!actionState.IsAdvanced) {
                    action.Dispose();
                    _plannedActions.TryGetFirstOutOfLine(out var _);
                    OnPlannedActionsChanged(new(transform));
                }
            }
        }
        public bool TryAddActionToPlan(IAction action) {
            var success = false;
            if (_plannedActions.TryWaitInLine(action)) {
                OnPlannedActionsChanged(new(transform));
                success = true;
            }
            return success;
        }
        public void Clear() {
            foreach (var action in _plannedActions) {
                action.Dispose();
            }
            _plannedActions.Clear();
            OnPlannedActionsChanged(new(transform));
        }
        public bool TryRemoveActionFromPlan(int index) {
            var success = false;
            if (_plannedActions.TryRemoveAt(index, out var _)) {
                success = true;
                OnPlannedActionsChanged(new(transform));
            }
            return success;
        }
        public IEnumerator<IActionRead> GetEnumerator() {
            return _plannedActions.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator() {
            return _plannedActions.GetEnumerator();
        }
    }
}

using System.Linq;
using TMPro;
using UnityEngine;
namespace TagFighter.UI
{
    public class WeavePicker : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("watchedRuneWeavingBank")]
        [SerializeField] RuneWeavingBank _watchedRuneWeavingBank;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        TMP_Dropdown _weaveDropDown;
        protected void Awake() {
            _weaveDropDown = GetComponent<TMP_Dropdown>();
        }
        protected void Start() {
            FillWeaveDropDown();
            _eventAggregator.RuneWeavingBankChanged += OnRuneWeavingBankChanged;
        }
        void OnRuneWeavingBankChanged(object sender, EventAggregator.RuneWeavingBankChangedEventArgs e) {
            FillWeaveDropDown();
        }
        void FillWeaveDropDown() {
            _weaveDropDown.ClearOptions();
            _weaveDropDown.AddOptions(_watchedRuneWeavingBank.GetWeaves().Select(weave => new TMP_Dropdown.OptionData(weave.WeaveName)).ToList());
        }
        protected void OnDestroy() {
            _eventAggregator.RuneWeavingBankChanged -= OnRuneWeavingBankChanged;
        }
    }
}

using System.Linq;
using TagFighter.Events;
using TMPro;
using UnityEngine;
namespace TagFighter.UI
{
    public class WeavePicker : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("watchedRuneWeavingBank")]
        [SerializeField] RuneWeavingBank _watchedRuneWeavingBank;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        TMP_Dropdown _weaveDropDown;
        protected void Awake() {
            _weaveDropDown = GetComponent<TMP_Dropdown>();
        }
        protected void Start() {
            FillWeaveDropDown();
            _eventAggregator.RuneWeavingBankChanged += OnRuneWeavingBankChanged;
        }
        void OnRuneWeavingBankChanged(object sender, EventAggregator.RuneWeavingBankChangedEventArgs e) {
            FillWeaveDropDown();
        }
        void FillWeaveDropDown() {
            _weaveDropDown.ClearOptions();
            _weaveDropDown.AddOptions(_watchedRuneWeavingBank.GetWeaves().Select(weave => new TMP_Dropdown.OptionData(weave.WeaveName)).ToList());
        }
        protected void OnDestroy() {
            _eventAggregator.RuneWeavingBankChanged -= OnRuneWeavingBankChanged;
        }
    }
}

using System;
using UnityEngine;
namespace TagFighter.UI
{
    public class WeaveBuilderScreenToggle : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        bool _show = false;
        Canvas _weaveBuilderScreen;
        protected void Awake() {
            _weaveBuilderScreen = transform.GetComponentInChildren<Canvas>(true);
        }
        protected void Start() {
            SetVisibility(_show);
            _eventAggregator.WeaveBuilderScreenToggleSelected += OnWeaveBuilderScreenToggleSelected;
        }
        protected void OnDestroy() {
            _eventAggregator.WeaveBuilderScreenToggleSelected -= OnWeaveBuilderScreenToggleSelected;
        }
        void OnWeaveBuilderScreenToggleSelected(object sender, EventArgs e) {
            _show = !_show;
            SetVisibility(_show);
        }
        void SetVisibility(bool visible) {
            _weaveBuilderScreen.gameObject.SetActive(visible);
        }
    }
}

using System;
using TagFighter.Events;
using UnityEngine;
namespace TagFighter.UI
{
    public class WeaveBuilderScreenToggle : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        bool _show = false;
        Canvas _weaveBuilderScreen;
        protected void Awake() {
            _weaveBuilderScreen = transform.GetComponentInChildren<Canvas>(true);
        }
        protected void Start() {
            SetVisibility(_show);
            _eventAggregator.WeaveBuilderScreenToggleSelected += OnWeaveBuilderScreenToggleSelected;
        }
        protected void OnDestroy() {
            _eventAggregator.WeaveBuilderScreenToggleSelected -= OnWeaveBuilderScreenToggleSelected;
        }
        void OnWeaveBuilderScreenToggleSelected(object sender, EventArgs e) {
            _show = !_show;
            SetVisibility(_show);
        }
        void SetVisibility(bool visible) {
            _weaveBuilderScreen.gameObject.SetActive(visible);
        }
    }
}

using TagFighter.Events;

using TagFighter.Events;

using UnityEngine;
namespace TagFighter.UI
{
    public class PawnSheetToggle : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        bool _show = false;
        Canvas _pawnSheetScreen;
        protected void Awake() {
            _pawnSheetScreen = transform.GetComponentInChildren<Canvas>(true);
            _eventAggregator.PawnSheetToggleSelected += OnPawnSheetToggleSelected;
        }
        protected void Start() {
            SetVisibility(_show);
        }
        protected void OnDestroy() {
            _eventAggregator.PawnSheetToggleSelected -= OnPawnSheetToggleSelected;
        }
        void OnPawnSheetToggleSelected(object sender, EventAggregator.PawnSheetToggleSelectedEventArgs e) {
            _show = !_show;
            SetVisibility(_show);
        }
        void SetVisibility(bool visible) {
            _pawnSheetScreen?.gameObject.SetActive(visible);
            if (visible) {
                _eventAggregator.OnPawnSheetShowed(this, new());
            }
            else {
                _eventAggregator.OnPawnSheetHid(this, new());
            }
        }
    }
    enum PawnSheetState
    {
        Uninit,
        Hidden,
        Shown
    }
}

using TagFighter.Events;
using UnityEngine;
namespace TagFighter.UI
{
    public class PawnSheetToggle : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        bool _show = false;
        Canvas _pawnSheetScreen;
        protected void Awake() {
            _pawnSheetScreen = transform.GetComponentInChildren<Canvas>(true);
            _eventAggregator.PawnSheetToggleSelected += OnPawnSheetToggleSelected;
        }
        protected void Start() {
            SetVisibility(_show);
        }
        protected void OnDestroy() {
            _eventAggregator.PawnSheetToggleSelected -= OnPawnSheetToggleSelected;
        }
        void OnPawnSheetToggleSelected(object sender, EventAggregator.PawnSheetToggleSelectedEventArgs e) {
            _show = !_show;
            SetVisibility(_show);
        }
        void SetVisibility(bool visible) {
            _pawnSheetScreen?.gameObject.SetActive(visible);
            if (visible) {
                _eventAggregator.OnPawnSheetShowed(this, new());
            }
            else {
                _eventAggregator.OnPawnSheetHid(this, new());
            }
        }
    }
    enum PawnSheetState
    {
        Uninit,
        Hidden,
        Shown
    }
}

using System.Collections.Generic;
using System.Linq;
using TagFighter.Equipment;
using UnityEngine;
namespace TagFighter.UI
{
    public class EquipmentNavigator : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        [SerializeField] ItemUI _itemUIPrefab;
        PartyMember _selectedPartyMember;
        Outfit _watchedOutfit;
        PawnSheetState _pawnSheetState = PawnSheetState.Uninit;
        [SerializeField] ItemSlotBank _itemSlotTypeIcons;
        IDictionary<ItemSlotType, Sprite> _spriteForItemSlotType;
        protected void Awake() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            _eventAggregator.PawnSheetShowed += OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid += OnPawnSheetHid;
            if (_itemSlotTypeIcons) {
                _spriteForItemSlotType = new Dictionary<ItemSlotType, Sprite>();
                foreach (var p in _itemSlotTypeIcons) {
                    _spriteForItemSlotType.TryAdd(p.ItemSlotType, p.Icon);
                }
            }
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            _eventAggregator.PawnSheetShowed -= OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid -= OnPawnSheetHid;
            if (_watchedOutfit != null) {
                _watchedOutfit.OutfitChanged -= OnOutfitChanged;
            }
        }
        void OnPawnSheetHid(object sender, EventAggregator.PawnSheetHidEventArgs e) {
            _pawnSheetState = PawnSheetState.Hidden;
        }
        void OnPawnSheetShowed(object sender, EventAggregator.PawnSheetShowedEventArgs e) {
            _pawnSheetState = PawnSheetState.Shown;
            if (_selectedPartyMember != null) {
                CreateEquipmentList(_selectedPartyMember);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent<PartyMember>(out var partyMember) && _selectedPartyMember != partyMember) {
                _selectedPartyMember = partyMember;
                ChangeOutfit(partyMember.GetComponent<Outfit>());
                if (_pawnSheetState == PawnSheetState.Shown) {
                    CreateEquipmentList(_selectedPartyMember);
                }
            }
        }
        void ChangeOutfit(Outfit outfit) {
            if (_watchedOutfit != null) {
                _watchedOutfit.OutfitChanged -= OnOutfitChanged;
            }
            if (outfit != null) {
                outfit.OutfitChanged += OnOutfitChanged;
            }
            _watchedOutfit = outfit;
        }
        void OnOutfitChanged(object sender, OutfitChangedEventArgs e) {
            if (_pawnSheetState == PawnSheetState.Shown) {
                CreateEquipmentList(_selectedPartyMember);
            }
        }
        void CreateEquipmentList(PartyMember partyMember) {
            var currentItemIndex = 0;
            HashSet<Item> equippedItems = new();
            foreach (var item in _watchedOutfit.Select(itemSlot => itemSlot.EquippedItem).Where(item => item != null)) {
                var itemUI = currentItemIndex < transform.childCount ?
                                  transform.GetChild(currentItemIndex).GetComponent<ItemUI>() :
                                  Instantiate(_itemUIPrefab, transform).GetComponent<ItemUI>();
                equippedItems.Add(item);
                itemUI.SetData(_watchedOutfit, item, _spriteForItemSlotType);
                itemUI.gameObject.SetActive(true);
                currentItemIndex++;
            }
            foreach (var item in partyMember.GetComponent<Backpack>().Where(item => !equippedItems.Contains(item))) {
                var itemUI = currentItemIndex < transform.childCount ?
                                  transform.GetChild(currentItemIndex).GetComponent<ItemUI>() :
                                  Instantiate(_itemUIPrefab, transform).GetComponent<ItemUI>();
                itemUI.SetData(_watchedOutfit, item, _spriteForItemSlotType);
                itemUI.gameObject.SetActive(true);
                currentItemIndex++;
            }
            for (; currentItemIndex < transform.childCount; currentItemIndex++) {
                transform.GetChild(currentItemIndex).gameObject.SetActive(false);
            }
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using TagFighter.Equipment;
using TagFighter.Events;
using UnityEngine;
namespace TagFighter.UI
{
    public class EquipmentNavigator : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        [SerializeField] ItemUI _itemUIPrefab;
        PartyMember _selectedPartyMember;
        Outfit _watchedOutfit;
        PawnSheetState _pawnSheetState = PawnSheetState.Uninit;
        [SerializeField] ItemSlotBank _itemSlotTypeIcons;
        IDictionary<ItemSlotType, Sprite> _spriteForItemSlotType;
        protected void Awake() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            _eventAggregator.PawnSheetShowed += OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid += OnPawnSheetHid;
            if (_itemSlotTypeIcons) {
                _spriteForItemSlotType = new Dictionary<ItemSlotType, Sprite>();
                foreach (var p in _itemSlotTypeIcons) {
                    _spriteForItemSlotType.TryAdd(p.ItemSlotType, p.Icon);
                }
            }
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            _eventAggregator.PawnSheetShowed -= OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid -= OnPawnSheetHid;
            if (_watchedOutfit != null) {
                _watchedOutfit.OutfitChanged -= OnOutfitChanged;
            }
        }
        void OnPawnSheetHid(object sender, EventAggregator.PawnSheetHidEventArgs e) {
            _pawnSheetState = PawnSheetState.Hidden;
        }
        void OnPawnSheetShowed(object sender, EventAggregator.PawnSheetShowedEventArgs e) {
            _pawnSheetState = PawnSheetState.Shown;
            if (_selectedPartyMember != null) {
                CreateEquipmentList(_selectedPartyMember);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent<PartyMember>(out var partyMember) && _selectedPartyMember != partyMember) {
                _selectedPartyMember = partyMember;
                ChangeOutfit(partyMember.GetComponent<Outfit>());
                if (_pawnSheetState == PawnSheetState.Shown) {
                    CreateEquipmentList(_selectedPartyMember);
                }
            }
        }
        void ChangeOutfit(Outfit outfit) {
            if (_watchedOutfit != null) {
                _watchedOutfit.OutfitChanged -= OnOutfitChanged;
            }
            if (outfit != null) {
                outfit.OutfitChanged += OnOutfitChanged;
            }
            _watchedOutfit = outfit;
        }
        void OnOutfitChanged(object sender, OutfitChangedEventArgs e) {
            if (_pawnSheetState == PawnSheetState.Shown) {
                CreateEquipmentList(_selectedPartyMember);
            }
        }
        void CreateEquipmentList(PartyMember partyMember) {
            var currentItemIndex = 0;
            HashSet<Item> equippedItems = new();
            foreach (var item in _watchedOutfit.Select(itemSlot => itemSlot.EquippedItem).Where(item => item != null)) {
                var itemUI = currentItemIndex < transform.childCount ?
                                  transform.GetChild(currentItemIndex).GetComponent<ItemUI>() :
                                  Instantiate(_itemUIPrefab, transform).GetComponent<ItemUI>();
                equippedItems.Add(item);
                itemUI.SetData(_watchedOutfit, item, _spriteForItemSlotType);
                itemUI.gameObject.SetActive(true);
                currentItemIndex++;
            }
            foreach (var item in partyMember.GetComponent<Backpack>().Where(item => !equippedItems.Contains(item))) {
                var itemUI = currentItemIndex < transform.childCount ?
                                  transform.GetChild(currentItemIndex).GetComponent<ItemUI>() :
                                  Instantiate(_itemUIPrefab, transform).GetComponent<ItemUI>();
                itemUI.SetData(_watchedOutfit, item, _spriteForItemSlotType);
                itemUI.gameObject.SetActive(true);
                currentItemIndex++;
            }
            for (; currentItemIndex < transform.childCount; currentItemIndex++) {
                transform.GetChild(currentItemIndex).gameObject.SetActive(false);
            }
        }
    }
}

using System.Threading;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.UI
{
    public class AttributeNavigator : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        [SerializeField] AttributeUI _attributeUIPrefab;
        PartyMember _selectedPartyMember;
        CancellationTokenSource _cancellationSource;
        PawnSheetState _pawnSheetState = PawnSheetState.Uninit;
        protected void Awake() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            _eventAggregator.PawnSheetShowed += OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid += OnPawnSheetHid;
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            _eventAggregator.PawnSheetShowed -= OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid -= OnPawnSheetHid;
            if (_cancellationSource != null) {
                _cancellationSource.Cancel();
                _cancellationSource.Dispose();
            }
        }
        void RegisterToResource(IWatchableResource resource, IResourceViewer resourceViewer, CancellationToken cancellationToken) {
            void Handler(object sender, ResourceChangeArgs e) {
                resourceViewer.UpdateView(e);
            }
            void UnregisterHandler() {
                resource.ResourceChanged -= Handler;
            }
            resource.ResourceChanged += Handler;
            cancellationToken.Register(UnregisterHandler);
            resourceViewer.UpdateView(resource.Status);
        }
        void OnPawnSheetHid(object sender, EventAggregator.PawnSheetHidEventArgs e) {
            _pawnSheetState = PawnSheetState.Hidden;
            _cancellationSource?.Cancel();
        }
        void OnPawnSheetShowed(object sender, EventAggregator.PawnSheetShowedEventArgs e) {
            _pawnSheetState = PawnSheetState.Shown;
            if (_selectedPartyMember != null) {
                _cancellationSource?.Cancel();
                CreateAttributeList(_selectedPartyMember);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent<PartyMember>(out var partyMember) && _selectedPartyMember != partyMember) {
                _selectedPartyMember = partyMember;
                if (_pawnSheetState == PawnSheetState.Shown) {
                    _cancellationSource?.Cancel();
                    CreateAttributeList(_selectedPartyMember);
                }
            }
        }
        void CreateAttributeList(PartyMember partyMember) {
            var currentAttributeIndex = 0;
            _cancellationSource = new();
            foreach (var resource in partyMember.GetComponents<IWatchableResource>()) {
                var attributeUI = currentAttributeIndex < transform.childCount ?
                                  transform.GetChild(currentAttributeIndex).GetComponent<AttributeUI>() :
                                  Instantiate(_attributeUIPrefab, transform).GetComponent<AttributeUI>();
                attributeUI.SetName(resource.GetType().Name);
                RegisterToResource(resource, attributeUI, _cancellationSource.Token);
                attributeUI.gameObject.SetActive(true);
                currentAttributeIndex++;
            }
            for (; currentAttributeIndex < transform.childCount; currentAttributeIndex++) {
                transform.GetChild(currentAttributeIndex).gameObject.SetActive(false);
            }
        }
    }
}

using System.Threading;
using TagFighter.Events;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.UI
{
    public class AttributeNavigator : MonoBehaviour
    {
        [SerializeField] EventAggregator _eventAggregator;
        [SerializeField] AttributeUI _attributeUIPrefab;
        PartyMember _selectedPartyMember;
        CancellationTokenSource _cancellationSource;
        PawnSheetState _pawnSheetState = PawnSheetState.Uninit;
        protected void Awake() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            _eventAggregator.PawnSheetShowed += OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid += OnPawnSheetHid;
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            _eventAggregator.PawnSheetShowed -= OnPawnSheetShowed;
            _eventAggregator.PawnSheetHid -= OnPawnSheetHid;
            if (_cancellationSource != null) {
                _cancellationSource.Cancel();
                _cancellationSource.Dispose();
            }
        }
        void RegisterToResource(IWatchableResource resource, IResourceViewer resourceViewer, CancellationToken cancellationToken) {
            void Handler(object sender, ResourceChangeArgs e) {
                resourceViewer.UpdateView(e);
            }
            void UnregisterHandler() {
                resource.ResourceChanged -= Handler;
            }
            resource.ResourceChanged += Handler;
            cancellationToken.Register(UnregisterHandler);
            resourceViewer.UpdateView(resource.Status);
        }
        void OnPawnSheetHid(object sender, EventAggregator.PawnSheetHidEventArgs e) {
            _pawnSheetState = PawnSheetState.Hidden;
            _cancellationSource?.Cancel();
        }
        void OnPawnSheetShowed(object sender, EventAggregator.PawnSheetShowedEventArgs e) {
            _pawnSheetState = PawnSheetState.Shown;
            if (_selectedPartyMember != null) {
                _cancellationSource?.Cancel();
                CreateAttributeList(_selectedPartyMember);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent<PartyMember>(out var partyMember) && _selectedPartyMember != partyMember) {
                _selectedPartyMember = partyMember;
                if (_pawnSheetState == PawnSheetState.Shown) {
                    _cancellationSource?.Cancel();
                    CreateAttributeList(_selectedPartyMember);
                }
            }
        }
        void CreateAttributeList(PartyMember partyMember) {
            var currentAttributeIndex = 0;
            _cancellationSource = new();
            foreach (var resource in partyMember.GetComponents<IWatchableResource>()) {
                var attributeUI = currentAttributeIndex < transform.childCount ?
                                  transform.GetChild(currentAttributeIndex).GetComponent<AttributeUI>() :
                                  Instantiate(_attributeUIPrefab, transform).GetComponent<AttributeUI>();
                attributeUI.SetName(resource.GetType().Name);
                RegisterToResource(resource, attributeUI, _cancellationSource.Token);
                attributeUI.gameObject.SetActive(true);
                currentAttributeIndex++;
            }
            for (; currentAttributeIndex < transform.childCount; currentAttributeIndex++) {
                transform.GetChild(currentAttributeIndex).gameObject.SetActive(false);
            }
        }
    }
}

using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter
{
    public class TechBuilderClicker : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleTechBuilderToggle();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleTechBuilderToggle() {
            _eventAggregator.OnWeaveBuilderScreenToggleSelected(this, new());
        }
    }
}

using TagFighter.Events;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter
{
    public class TechBuilderClicker : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleTechBuilderToggle();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleTechBuilderToggle() {
            _eventAggregator.OnWeaveBuilderScreenToggleSelected(this, new());
        }
    }
}

using System.Linq;
using TagFighter.Equipment;
using UnityEngine;
namespace TagFighter.UI
{
    public class RuneWeaveView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("weaveSelectButtonTemplate")]
        public Transform WeaveSelectButtonTemplate;
        [UnityEngine.Serialization.FormerlySerializedAs("watchedRuneWeavingBank")]
        public RuneWeavingBank WatchedRuneWeavingBank;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        Outfit _watchedOutfit;
        Weaver _selectedWeaver;
        Weaver SelectedWeaver {
            get {
                return _selectedWeaver;
            }
            set {
                if (_selectedWeaver != null) {
                    _eventAggregator.RuneWeavingBankChanged -= OnRuneWeavingBankChanged;
                    if (_watchedOutfit != null) {
                        _watchedOutfit.OutfitChanged -= OnOutfitChanged;
                    }
                }
                _selectedWeaver = value;
                if (_selectedWeaver != null) {
                    _eventAggregator.RuneWeavingBankChanged += OnRuneWeavingBankChanged;
                    if (SelectedWeaver.TryGetComponent(out _watchedOutfit)) {
                        _watchedOutfit.OutfitChanged += OnOutfitChanged;
                    }
                }
            }
        }
        protected void Start() {
            Clear();
            _eventAggregator.UnitSelected += OnUnitSelected;
        }
        protected void OnDestroy() {
            SelectedWeaver = null;
            _eventAggregator.UnitSelected -= OnUnitSelected;
            Clear();
        }
        void OnRuneWeavingBankChanged(object sender, EventAggregator.RuneWeavingBankChangedEventArgs e) {
            if (WatchedRuneWeavingBank == e.Bank) {
                CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if ((e.UnitTransform.GetComponent<PartyMember>() != null) && e.UnitTransform.TryGetComponent<Weaver>(out var weaver)) {
                SelectedWeaver = weaver;
                CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
            }
        }
        void OnOutfitChanged(object sender, OutfitChangedEventArgs e) {
            CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
        }
        void CreateWeaveSelectionButtons(RuneWeavingBank bank, Weaver weaver) {
            var currentWeaveIndex = 0;
            var originalChildCount = transform.childCount - 1; // excluding template
            foreach (var weave in bank.GetWeaves().Where(weave => weaver.CanUseWeave(weave.RuneWeaving))) {
                RuneWeaveSelectUI runeWeaveSelectUI;
                if (currentWeaveIndex < originalChildCount) {
                    runeWeaveSelectUI = transform.GetChild(currentWeaveIndex + 1).GetComponent<RuneWeaveSelectUI>();
                }
                else {
                    runeWeaveSelectUI = Instantiate(WeaveSelectButtonTemplate, transform).GetComponent<RuneWeaveSelectUI>();
                }
                runeWeaveSelectUI.SetRuneWeave(weave);
                runeWeaveSelectUI.gameObject.SetActive(true);
                currentWeaveIndex++;
            }
            for (; currentWeaveIndex < transform.childCount - 1; currentWeaveIndex++) {
                transform.GetChild(currentWeaveIndex + 1).gameObject.SetActive(false);
            }
        }
        void Clear() {
            // Making sure to skip the template
            foreach (Transform item in transform) {
                if (item.GetComponent<RuneWeaveSelectUI>() != null) {
                    Destroy(item.gameObject);
                }
            }
        }
    }
}

using System.Linq;
using TagFighter.Equipment;
using TagFighter.Events;
using UnityEngine;
namespace TagFighter.UI
{
    public class RuneWeaveView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("weaveSelectButtonTemplate")]
        public Transform WeaveSelectButtonTemplate;
        [UnityEngine.Serialization.FormerlySerializedAs("watchedRuneWeavingBank")]
        public RuneWeavingBank WatchedRuneWeavingBank;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        Outfit _watchedOutfit;
        Weaver _selectedWeaver;
        Weaver SelectedWeaver {
            get {
                return _selectedWeaver;
            }
            set {
                if (_selectedWeaver != null) {
                    _eventAggregator.RuneWeavingBankChanged -= OnRuneWeavingBankChanged;
                    if (_watchedOutfit != null) {
                        _watchedOutfit.OutfitChanged -= OnOutfitChanged;
                    }
                }
                _selectedWeaver = value;
                if (_selectedWeaver != null) {
                    _eventAggregator.RuneWeavingBankChanged += OnRuneWeavingBankChanged;
                    if (SelectedWeaver.TryGetComponent(out _watchedOutfit)) {
                        _watchedOutfit.OutfitChanged += OnOutfitChanged;
                    }
                }
            }
        }
        protected void Start() {
            Clear();
            _eventAggregator.UnitSelected += OnUnitSelected;
        }
        protected void OnDestroy() {
            SelectedWeaver = null;
            _eventAggregator.UnitSelected -= OnUnitSelected;
            Clear();
        }
        void OnRuneWeavingBankChanged(object sender, EventAggregator.RuneWeavingBankChangedEventArgs e) {
            if (WatchedRuneWeavingBank == e.Bank) {
                CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if ((e.UnitTransform.GetComponent<PartyMember>() != null) && e.UnitTransform.TryGetComponent<Weaver>(out var weaver)) {
                SelectedWeaver = weaver;
                CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
            }
        }
        void OnOutfitChanged(object sender, OutfitChangedEventArgs e) {
            CreateWeaveSelectionButtons(WatchedRuneWeavingBank, SelectedWeaver);
        }
        void CreateWeaveSelectionButtons(RuneWeavingBank bank, Weaver weaver) {
            var currentWeaveIndex = 0;
            var originalChildCount = transform.childCount - 1; // excluding template
            foreach (var weave in bank.GetWeaves().Where(weave => weaver.CanUseWeave(weave.RuneWeaving))) {
                RuneWeaveSelectUI runeWeaveSelectUI;
                if (currentWeaveIndex < originalChildCount) {
                    runeWeaveSelectUI = transform.GetChild(currentWeaveIndex + 1).GetComponent<RuneWeaveSelectUI>();
                }
                else {
                    runeWeaveSelectUI = Instantiate(WeaveSelectButtonTemplate, transform).GetComponent<RuneWeaveSelectUI>();
                }
                runeWeaveSelectUI.SetRuneWeave(weave);
                runeWeaveSelectUI.gameObject.SetActive(true);
                currentWeaveIndex++;
            }
            for (; currentWeaveIndex < transform.childCount - 1; currentWeaveIndex++) {
                transform.GetChild(currentWeaveIndex + 1).gameObject.SetActive(false);
            }
        }
        void Clear() {
            // Making sure to skip the template
            foreach (Transform item in transform) {
                if (item.GetComponent<RuneWeaveSelectUI>() != null) {
                    Destroy(item.gameObject);
                }
            }
        }
    }
}

using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter.UI
{
    public class RuneWeaveSelectUI : MonoBehaviour, IPointerClickHandler
    {
        [UnityEngine.Serialization.FormerlySerializedAs("weaveName")]
        [SerializeField] TextMeshProUGUI _weaveName;
        RuneWeavingContainer _runeWeave;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleSelectWeave();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleSelectWeave() {
            _eventAggregator.OnRuneWeavingCastSelected(this, new(_runeWeave));
        }
        public void SetRuneWeave(RuneWeavingContainer runeWeave) {
            _runeWeave = runeWeave;
            SetWeaveName(_runeWeave.WeaveName);
        }
        void SetWeaveName(string weaveName) {
            this._weaveName.text = weaveName;
        }
    }
}

using TagFighter.Events;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter.UI
{
    public class RuneWeaveSelectUI : MonoBehaviour, IPointerClickHandler
    {
        [UnityEngine.Serialization.FormerlySerializedAs("weaveName")]
        [SerializeField] TextMeshProUGUI _weaveName;
        RuneWeavingContainer _runeWeave;
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleSelectWeave();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleSelectWeave() {
            _eventAggregator.OnRuneWeavingCastSelected(this, new(_runeWeave));
        }
        public void SetRuneWeave(RuneWeavingContainer runeWeave) {
            _runeWeave = runeWeave;
            SetWeaveName(_runeWeave.WeaveName);
        }
        void SetWeaveName(string weaveName) {
            this._weaveName.text = weaveName;
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using TagFighter.Actions;
using UnityEngine;
namespace TagFighter.UI
{
    public class PlannedActionsView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        public List<PlannedActionClicker> PlannedActionsUI;
        ActionPlan _watchedActionPlan;
        ActionPlan WatcedActionPlan {
            get {
                return _watchedActionPlan;
            }
            set {
                if (_watchedActionPlan != null) {
                    _watchedActionPlan.PlanChanged -= OnPlannedActionsChanged;
                }
                _watchedActionPlan = value;
                if (_watchedActionPlan != null) {
                    _watchedActionPlan.PlanChanged += OnPlannedActionsChanged;
                }
            }
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            WatcedActionPlan = null;
        }
        protected void Start() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            for (var i = 0; i < PlannedActionsUI.Count(); ++i) {
                var uiClicker = PlannedActionsUI[i];
                uiClicker.SetActionName("");
                uiClicker.Index = i;
            }
        }
        void OnPlannedActionsChanged(object sender, UnitActionEventArgs e) {
            UpdatePlannedActions(e.UnitTransform.GetComponent<ActionPlan>());
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if ((e.UnitTransform.GetComponent<PartyMember>() != null) && e.UnitTransform.TryGetComponent<ActionPlan>(out var actionPlan)) {
                WatcedActionPlan = actionPlan;
                UpdatePlannedActions(WatcedActionPlan);
            }
        }
        void UpdatePlannedActions(ActionPlan actionPlan) {
            var count = 0;
            foreach (var item in actionPlan.Zip(PlannedActionsUI, (action, uiClicker) => (action, uiClicker))) {
                item.uiClicker.SetActionName(item.action.ToString());
                if (item.uiClicker.TryGetComponent(out PlannedActionStatus statusWatcher)) {
                    statusWatcher.SetWatched(item.action);
                }
                count++;
            }
            foreach (var uiClicker in PlannedActionsUI.Skip(count)) {
                uiClicker.SetActionName("");
                if (uiClicker.TryGetComponent(out PlannedActionStatus statusWatcher)) {
                    statusWatcher.SetWatched(null);
                }
            }
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using TagFighter.Actions;
using TagFighter.Events;
using UnityEngine;
namespace TagFighter.UI
{
    public class PlannedActionsView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("eventAggregator")]
        [SerializeField] EventAggregator _eventAggregator;
        public List<PlannedActionClicker> PlannedActionsUI;
        ActionPlan _watchedActionPlan;
        ActionPlan WatcedActionPlan {
            get {
                return _watchedActionPlan;
            }
            set {
                if (_watchedActionPlan != null) {
                    _watchedActionPlan.PlanChanged -= OnPlannedActionsChanged;
                }
                _watchedActionPlan = value;
                if (_watchedActionPlan != null) {
                    _watchedActionPlan.PlanChanged += OnPlannedActionsChanged;
                }
            }
        }
        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            WatcedActionPlan = null;
        }
        protected void Start() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            for (var i = 0; i < PlannedActionsUI.Count(); ++i) {
                var uiClicker = PlannedActionsUI[i];
                uiClicker.SetActionName("");
                uiClicker.Index = i;
            }
        }
        void OnPlannedActionsChanged(object sender, UnitActionEventArgs e) {
            UpdatePlannedActions(e.UnitTransform.GetComponent<ActionPlan>());
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if ((e.UnitTransform.GetComponent<PartyMember>() != null) && e.UnitTransform.TryGetComponent<ActionPlan>(out var actionPlan)) {
                WatcedActionPlan = actionPlan;
                UpdatePlannedActions(WatcedActionPlan);
            }
        }
        void UpdatePlannedActions(ActionPlan actionPlan) {
            var count = 0;
            foreach (var item in actionPlan.Zip(PlannedActionsUI, (action, uiClicker) => (action, uiClicker))) {
                item.uiClicker.SetActionName(item.action.ToString());
                if (item.uiClicker.TryGetComponent(out PlannedActionStatus statusWatcher)) {
                    statusWatcher.SetWatched(item.action);
                }
                count++;
            }
            foreach (var uiClicker in PlannedActionsUI.Skip(count)) {
                uiClicker.SetActionName("");
                if (uiClicker.TryGetComponent(out PlannedActionStatus statusWatcher)) {
                    statusWatcher.SetWatched(null);
                }
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
namespace TagFighter.UI
{
    [RequireComponent(typeof(Image))]
    public class PlannedActionStatus : MonoBehaviour
    {
        Image _status;
        IAction _watched;
        protected void Start() {
            _status = GetComponent<Image>();
        }
        protected void Update() {
            if (_watched != null) {
                _status.fillAmount = _watched.CompletionStatus();
            }
        }
        public void SetWatched(IAction action) {
            _watched = action;
            if (_watched == null) {
                _status.fillAmount = 0;
            }
            else {
                _status.fillAmount = _watched.CompletionStatus();
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
namespace TagFighter.UI
{
    [RequireComponent(typeof(Image))]
    public class PlannedActionStatus : MonoBehaviour
    {
        Image _status;
        IActionRead _watched;
        protected void Start() {
            _status = GetComponent<Image>();
        }
        protected void Update() {
            if (_watched != null) {
                _status.fillAmount = _watched.CompletionStatus();
            }
        }
        public void SetWatched(IActionRead action) {
            _watched = action;
            if (_watched == null) {
                _status.fillAmount = 0;
            }
            else {
                _status.fillAmount = _watched.CompletionStatus();
            }
        }
    }
}

using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter.UI
{
    public class PlannedActionClicker : MonoBehaviour, IPointerClickHandler
    {
        public int Index { get; set; }
        TMP_Text _actionName;
        [SerializeField] EventAggregator _eventAggregator;
        protected void Awake() {
            _actionName = GetComponentInChildren<TMP_Text>();
        }
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    break;
                case PointerEventData.InputButton.Right:
                    HandleRemoveFromPlannedActions();
                    break;
            }
        }
        public void SetActionName(string actionName) {
            _actionName.text = actionName;
        }
        void HandleRemoveFromPlannedActions() {
            _eventAggregator.OnRemovePlannedActionSelected(this, new(Index));
        }
    }
}

using TagFighter.Events;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter.UI
{
    public class PlannedActionClicker : MonoBehaviour, IPointerClickHandler
    {
        public int Index { get; set; }
        TMP_Text _actionName;
        [SerializeField] EventAggregator _eventAggregator;
        protected void Awake() {
            _actionName = GetComponentInChildren<TMP_Text>();
        }
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    break;
                case PointerEventData.InputButton.Right:
                    HandleRemoveFromPlannedActions();
                    break;
            }
        }
        public void SetActionName(string actionName) {
            _actionName.text = actionName;
        }
        void HandleRemoveFromPlannedActions() {
            _eventAggregator.OnRemovePlannedActionSelected(this, new(Index));
        }
    }
}

using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.UI
{
    public class PartyView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("partyMemberUnitFrame")]
        [SerializeField] Transform _partyMemberUnitFrame;
        [UnityEngine.Serialization.FormerlySerializedAs("partyToDisplay")]
        [SerializeField] Party _partyToDisplay;
        [SerializeField] EventAggregator _eventAggregator;
        protected void OnDestroy() {
            _partyToDisplay.OnCompositionChanged -= Party_OnCompositionChanged;
            _eventAggregator.UnitSelected -= OnUnitSelected;
        }
        protected void Start() {
            _partyToDisplay.OnCompositionChanged += Party_OnCompositionChanged;
            _eventAggregator.UnitSelected += OnUnitSelected;
        }
        void Party_OnCompositionChanged(object sender, PartyCompositionArgs e) {
            foreach (Transform partyMemberPortrait in transform) {
                Destroy(partyMemberPortrait.gameObject);
            }
            foreach (var partyMember in e.PartyMembers) {
                var partyMemberPortraitTransform = Instantiate(_partyMemberUnitFrame, transform);
                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();
                partyMemberPortrait.SetPartyMember(partyMember);
                var partyMemberResources = partyMemberPortraitTransform.GetComponentsInChildren<ResourceWatcher>();
                partyMemberResources[0].WatchedResource = partyMember.GetComponent<Pain>();
                partyMemberResources[1].WatchedResource = partyMember.GetComponent<Fatigue>();
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent(out PartyMember partyMember)) {
                SetSelectedPortrait(partyMember);
            }
        }
        void SetSelectedPortrait(PartyMember partyMember) {
            foreach (Transform partyMemberPortraitTransform in transform) {
                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();
                partyMemberPortrait.SetSelected(partyMemberPortrait.GetPartyMember() == partyMember);
            }
        }
    }
}

using TagFighter.Events;
using TagFighter.Resources;
using UnityEngine;
namespace TagFighter.UI
{
    public class PartyView : MonoBehaviour
    {
        [UnityEngine.Serialization.FormerlySerializedAs("partyMemberUnitFrame")]
        [SerializeField] Transform _partyMemberUnitFrame;
        [UnityEngine.Serialization.FormerlySerializedAs("partyToDisplay")]
        [SerializeField] Party _partyToDisplay;
        [SerializeField] EventAggregator _eventAggregator;
        protected void OnDestroy() {
            _partyToDisplay.OnCompositionChanged -= Party_OnCompositionChanged;
            _eventAggregator.UnitSelected -= OnUnitSelected;
        }
        protected void Start() {
            _partyToDisplay.OnCompositionChanged += Party_OnCompositionChanged;
            _eventAggregator.UnitSelected += OnUnitSelected;
        }
        void Party_OnCompositionChanged(object sender, PartyCompositionArgs e) {
            foreach (Transform partyMemberPortrait in transform) {
                Destroy(partyMemberPortrait.gameObject);
            }
            foreach (var partyMember in e.PartyMembers) {
                var partyMemberPortraitTransform = Instantiate(_partyMemberUnitFrame, transform);
                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();
                partyMemberPortrait.SetPartyMember(partyMember);
                var partyMemberResources = partyMemberPortraitTransform.GetComponentsInChildren<ResourceWatcher>();
                partyMemberResources[0].WatchedResource = partyMember.GetComponent<Pain>();
                partyMemberResources[1].WatchedResource = partyMember.GetComponent<Fatigue>();
            }
        }
        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            if (e.UnitTransform.TryGetComponent(out PartyMember partyMember)) {
                SetSelectedPortrait(partyMember);
            }
        }
        void SetSelectedPortrait(PartyMember partyMember) {
            foreach (Transform partyMemberPortraitTransform in transform) {
                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();
                partyMemberPortrait.SetSelected(partyMemberPortrait.GetPartyMember() == partyMember);
            }
        }
    }
}

using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
namespace TagFighter.UI
{
    [RequireComponent(typeof(Button))]
    public class PartyMemberPortrait : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        Button _portrait;
        TextMeshProUGUI _characterName;
        PartyMember _partyMember;
        protected void Awake() {
            _portrait = GetComponent<Button>();
            _characterName = GetComponentInChildren<TextMeshProUGUI>();
        }
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleSelectPartyMember();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        public void SetSelected(bool isSelected) {
            _portrait.GetComponent<Outline>().enabled = isSelected;
        }
        public void SetPartyMember(PartyMember partyMember) {
            _partyMember = partyMember;
            SetPartyMemberName(partyMember.name);
        }
        public PartyMember GetPartyMember() => _partyMember;
        void HandleSelectPartyMember() {
            _eventAggregator.OnUnitSelected(this, new(_partyMember.transform));
        }
        void SetPartyMemberName(string partyMemberName) {
            _characterName.text = partyMemberName;
        }
    }
}

using TagFighter.Events;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
namespace TagFighter.UI
{
    [RequireComponent(typeof(Button))]
    public class PartyMemberPortrait : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        Button _portrait;
        TextMeshProUGUI _characterName;
        PartyMember _partyMember;
        protected void Awake() {
            _portrait = GetComponent<Button>();
            _characterName = GetComponentInChildren<TextMeshProUGUI>();
        }
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleSelectPartyMember();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        public void SetSelected(bool isSelected) {
            _portrait.GetComponent<Outline>().enabled = isSelected;
        }
        public void SetPartyMember(PartyMember partyMember) {
            _partyMember = partyMember;
            SetPartyMemberName(partyMember.name);
        }
        public PartyMember GetPartyMember() => _partyMember;
        void HandleSelectPartyMember() {
            _eventAggregator.OnUnitSelected(this, new(_partyMember.transform));
        }
        void SetPartyMemberName(string partyMemberName) {
            _characterName.text = partyMemberName;
        }
    }
}

using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter
{
    public class CharacterSheetClicker : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleCharacterSheetToggle();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleCharacterSheetToggle() {
            _eventAggregator.OnPawnSheetToggleSelected(this, new());
        }
    }
}

using TagFighter.Events;
using UnityEngine;
using UnityEngine.EventSystems;
namespace TagFighter
{
    public class CharacterSheetClicker : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] EventAggregator _eventAggregator;
        public void OnPointerClick(PointerEventData eventData) {
            switch (eventData.button) {
                case PointerEventData.InputButton.Left:
                    HandleCharacterSheetToggle();
                    break;
                case PointerEventData.InputButton.Right:
                    break;
            }
        }
        void HandleCharacterSheetToggle() {
            _eventAggregator.OnPawnSheetToggleSelected(this, new());
        }
    }
}

using System.Collections;
using TagFighter;
using TagFighter.Resources;
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;
    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();
        }
    }
    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 TestPhysics() {
        if (Input.GetKeyDown(KeyCode.T)) {
            if (Input.GetKey(KeyCode.LeftShift)) {
                Test();
            }
            else {
                _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;
        }
    }
    void Test() {
        TimeDialationTester timeDialationTester = new(_eventAggregator);
        timeDialationTester.TestAll();
        LineTester lineTester = new();
        lineTester.TestAll();
    }
}
namespace Testing.TimeDialation
{
    public class TimeDialationTester
    {
        EventAggregator _eventAggregator;
        public TimeDialationTester(EventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
        }
        public void TestAll() {
            TestTimeDialationSpeedUp();
            TestTimeDialationSpeedDown();
            TestTimeDialationSpeedPause();
            TestTimeDialationSpeedReset();
        }
        public void TestTimeDialationSpeedUp() {
            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedUp(this, System.EventArgs.Empty);
            if (Time.timeScale > currentTimeScale) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedDown() {
            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedDown(this, System.EventArgs.Empty);
            if (Time.timeScale < currentTimeScale) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedPause() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedPause(this, System.EventArgs.Empty);
            if (Time.timeScale == 0) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedReset() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            Time.timeScale = 4;
            _eventAggregator.OnTimeDilationSpeedReset(this, System.EventArgs.Empty);
            if (Time.timeScale == 1) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
    }
}
namespace Testing.Line
{
    public class LineTester
    {
        public void TestAll() {
            TestWaitInLine();
            TestCutInLine();
            TestTryRemoveAt();
            TestCircularInsert();
        }
        public void TestWaitInLine() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
        

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>");
            }
        }
        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;
        }
        public void TestAll() {
            TestTimeDialationSpeedUp();
            TestTimeDialationSpeedDown();
            TestTimeDialationSpeedPause();
            TestTimeDialationSpeedReset();
        }
        public void TestTimeDialationSpeedUp() {
            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedUp(this, System.EventArgs.Empty);
            if (Time.timeScale > currentTimeScale) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedDown() {
            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedDown(this, System.EventArgs.Empty);
            if (Time.timeScale < currentTimeScale) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedPause() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            _eventAggregator.OnTimeDilationSpeedPause(this, System.EventArgs.Empty);
            if (Time.timeScale == 0) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
        public void TestTimeDialationSpeedReset() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            Time.timeScale = 4;
            _eventAggregator.OnTimeDilationSpeedReset(this, System.EventArgs.Empty);
            if (Time.timeScale == 1) {
                Debug.Log($"<color=green>PASSED: {testName}</color>");
            }
            else {
                Debug.Log($"<color=red>FAILED: {testName}</color>");
            }
        }
    }
}
namespace Testing.Line
{
    public class LineTester
    {
        public void TestAll() {
            TestWaitInLine();
            TestCutInLine();
            TestTryRemoveAt();
            TestCircularInsert();
        }
        public void TestWaitInLine() {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;