public class Weaver : MonoBehaviour

namespace TagFighter

    [SerializeField] Inventory _inventory;
    [SerializeField] List<CombatFormRef> _knownForms;
    Weapon _equippedWeapon;
    CombatForm _equippedForm;
    Dictionary<Weapon, CombatForm> _preferedCombatFormByWeapon = new();
    Line<IAction> _plannedActions = new(capacity: 6);

    public class Weaver : MonoBehaviour
    {
        [SerializeField] Inventory _inventory;
        [SerializeField] List<CombatFormRef> _knownForms;
        Weapon _equippedWeapon;
        CombatForm _equippedForm;
        Dictionary<Weapon, CombatForm> _preferedCombatFormByWeapon = new();
        Line<IAction> _plannedActions = new(capacity: 6);

    public event EventHandler<WeaponEquippedEventArgs> WeaponEquipped;
    public event EventHandler<CombatFormEquippedEventArgs> CombatFormEquipped;
    public event EventHandler<TakeActionEventArgs> ActionTaken;
    public event EventHandler<UnitActionEventArgs> PlannedActionsChanged;

        public event EventHandler<WeaponEquippedEventArgs> WeaponEquipping;
        public event EventHandler<WeaponEquippedEventArgs> WeaponEquipped;
        public event EventHandler<CombatFormEquippedEventArgs> CombatFormEquipped;
        public event EventHandler<TakeActionEventArgs> ActionTaken;
        public event EventHandler<UnitActionEventArgs> PlannedActionsChanged;

    protected void OnWeaponEquipped(WeaponEquippedEventArgs e) {
        WeaponEquipped?.Invoke(this, e);
    }

        protected void OnWeaponEquipping(WeaponEquippedEventArgs e) {
            WeaponEquipping?.Invoke(this, e);
        }

    protected void OnCombatFormEquipped(CombatFormEquippedEventArgs e) {
        CombatFormEquipped?.Invoke(this, e);
    }

        protected void OnWeaponEquipped(WeaponEquippedEventArgs e) {
            WeaponEquipped?.Invoke(this, e);
        }

    protected void OnActionTaken(TakeActionEventArgs e) {
        ActionTaken?.Invoke(this, e);
    }
    protected void OnPlannedActionsChanged(UnitActionEventArgs e) {
        PlannedActionsChanged?.Invoke(this, e);
    }

        protected void OnCombatFormEquipped(CombatFormEquippedEventArgs e) {
            CombatFormEquipped?.Invoke(this, e);
        }
        protected void OnActionTaken(TakeActionEventArgs e) {
            ActionTaken?.Invoke(this, e);
        }
        protected void OnPlannedActionsChanged(UnitActionEventArgs e) {
            PlannedActionsChanged?.Invoke(this, e);
        }
        protected void Start() {
            EquipAnyWeapon();
        }

    protected void Start() {
        EquipAnyWeapon();
    }

        protected void Update() {
            if (_plannedActions.TryPeek(out var action)) {
                var actionState = action.Advance();
                OnActionTaken(new(actionState));

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

            if (!actionState.IsAdvanced) {
                action.Cancel();
                _plannedActions.TryGetFirstOutOfLine(out var _);

        bool PlanAction(IAction action) {
            var success = false;
            if (_plannedActions.TryWaitInLine(action)) {

                success = true;

            return success;

    }

    bool PlanAction(IAction action) {
        var success = false;
        if (_plannedActions.TryWaitInLine(action)) {
            OnPlannedActionsChanged(new(transform));
            success = true;

        void SetCombatForm(CombatForm combatForm) {
            _equippedForm = combatForm;
            OnCombatFormEquipped(new(_equippedForm, this));

        return success;
    }

    void SetCombatForm(CombatForm combatForm) {
        _equippedForm = combatForm;
        OnCombatFormEquipped(new(_equippedForm, this));
    }

        void EquipPreferredCombatFormOfWeapon(Weapon weapon) {
            _preferedCombatFormByWeapon.TryGetValue(weapon, out var tryEquipForm);
            SetCombatForm(tryEquipForm);
        }

    void EquipPreferredCombatFormOfWeapon(Weapon weapon) {
        _preferedCombatFormByWeapon.TryGetValue(weapon, out var tryEquipForm);
        SetCombatForm(tryEquipForm);
    }
    void EquipAnyWeapon() {
        var tryEquipWeapon = _inventory.GetAvailableWeapons().First();
        if (tryEquipWeapon != null) {
            TryDrawWeapon(tryEquipWeapon.Name);
        }
    }
    public bool TryDrawWeapon(string weaponName) {
        var isWeaponInInventory = false;
        if (_inventory) {
            isWeaponInInventory = _inventory.TryGetWeaponByName(weaponName, out var tryEquipWeapon);
            if (isWeaponInInventory) {
                ClearActionPlan();
                _equippedWeapon = tryEquipWeapon;
                OnWeaponEquipped(new(_equippedWeapon, this));
                EquipPreferredCombatFormOfWeapon(_equippedWeapon);

        void EquipAnyWeapon() {
            var tryEquipWeapon = _inventory.GetAvailableWeapons().First();
            if (tryEquipWeapon != null) {
                TryDrawWeapon(tryEquipWeapon.Name);

        return isWeaponInInventory;
    }
    public bool TryEquipCombatForm(string combatFormName) {
        CombatForm combatForm = GetAvailableCombatFormsForEquipedWeapon().Where(combatForm => combatForm.name == combatFormName).FirstOrDefault();
        _preferedCombatFormByWeapon[_equippedWeapon] = combatForm;
        SetCombatForm(combatForm);

        public bool TryDrawWeapon(string weaponName) {
            var isWeaponInInventory = false;
            if (_inventory) {
                isWeaponInInventory = _inventory.TryGetWeaponByName(weaponName, out var tryEquipWeapon);
                if (isWeaponInInventory) {
                    ClearActionPlan();
                    var previousWeapon = _equippedWeapon;
                    _equippedWeapon = tryEquipWeapon;
                    OnWeaponEquipping(new(previousWeapon, _equippedWeapon, this));
                    EquipPreferredCombatFormOfWeapon(_equippedWeapon);
                    OnWeaponEquipped(new(previousWeapon, _equippedWeapon, this));
                }
            }

        return combatForm != null;
    }

            return isWeaponInInventory;
        }
        public bool TryEquipCombatForm(string combatFormName) {
            CombatForm combatForm = GetAvailableCombatFormsForEquipedWeapon().Where(combatForm => combatForm.name == combatFormName).FirstOrDefault();
            _preferedCombatFormByWeapon[_equippedWeapon] = combatForm;
            SetCombatForm(combatForm);

    public bool TryQueueWeave(RuneWeavingContainer weaving, Transform target) {
        WeaveAction weaveAction = new(this, weaving, target, _equippedWeapon.GetRange());
        var success = PlanAction(weaveAction);
        return success;
    }

            return combatForm != null;
        }

    public bool TryQueueFollow(Transform target) {
        FollowAction followAction = new(this, target, _equippedWeapon.GetRange());
        var success = PlanAction(followAction);
        return success;
    }

        public bool TryQueueWeave(RuneWeavingContainer weaving, Transform target) {
            WeaveAction weaveAction = new(this, weaving, target, GetComponent<Resources.Range>());
            var success = PlanAction(weaveAction);
            return success;
        }

    public bool TryQueueMove(Vector3 target) {
        MoveToAction moveToAction = new(this, target);
        var success = PlanAction(moveToAction);
        return success;
    }

        public bool TryQueueFollow(Transform target) {
            FollowAction followAction = new(this, target);
            var success = PlanAction(followAction);
            return success;
        }

    public void ClearActionPlan() {
        foreach (var action in _plannedActions) {
            action.Cancel();

        public bool TryQueueMove(Vector3 target) {
            MoveToAction moveToAction = new(this, target);
            var success = PlanAction(moveToAction);
            return success;

        _plannedActions.Clear();
        OnPlannedActionsChanged(new(transform));
    }

    public bool TryRemoveActionFromPlan(int index) {
        var success = false;
        if (_plannedActions.TryRemoveAt(index, out var _)) {
            success = true;

        public void ClearActionPlan() {
            foreach (var action in _plannedActions) {
                action.Dispose();
            }
            _plannedActions.Clear();

        return success;
    }

        public bool TryRemoveActionFromPlan(int index) {
            var success = false;
            if (_plannedActions.TryRemoveAt(index, out var _)) {
                success = true;
                OnPlannedActionsChanged(new(transform));
            }
            return success;
        }

    public bool CanUseWeave(RuneWeaving weave) {
        var weaponMoveSet = _equippedWeapon.GetCombatMoveSetRef().CombatMoveSet.CombatMoves();
        var weaveMoveSet = weave.MartialSequence.GetSequence().Select(moveRef => moveRef.CombatMove);
        return weaveMoveSet.All(weaveMove => weaponMoveSet.Any(weaponMove => weaveMove.MoveName == weaponMove.CombatMove.MoveName));
    }

        public bool CanUseWeave(RuneWeaving weave) {
            var weaponMoveSet = _equippedWeapon.GetCombatMoveSetRef().CombatMoveSet.CombatMoves();
            var weaveMoveSet = weave.MartialSequence.GetSequence().Select(moveRef => moveRef.CombatMove);
            return weaveMoveSet.All(weaveMove => weaponMoveSet.Any(weaponMove => weaveMove.MoveName == weaponMove.CombatMove.MoveName));
        }

    public Weapon EquippedWeapon => _equippedWeapon;
    public CombatForm EquippedForm => _equippedForm;
    public IEnumerable<Weapon> GetWeaponsInInventory() => _inventory.GetAvailableWeapons();
    public IEnumerable<CombatFormRef> GetAvailableCombatFormsForEquipedWeapon() => _knownForms.Select(combatFormRef => combatFormRef).Intersect(_equippedWeapon.GetCompatibleFormRefs());
    public IEnumerable<IAction> GetPlannedActions() => _plannedActions;

        public Weapon EquippedWeapon => _equippedWeapon;
        public CombatForm EquippedForm => _equippedForm;
        public IEnumerable<Weapon> GetWeaponsInInventory() => _inventory.GetAvailableWeapons();
        public IEnumerable<CombatFormRef> GetAvailableCombatFormsForEquipedWeapon() => _knownForms.Select(combatFormRef => combatFormRef).Intersect(_equippedWeapon.GetCompatibleFormRefs());
        public IEnumerable<IAction> GetPlannedActions() => _plannedActions;

    public class WeaponEquippedEventArgs : EventArgs
    {
        public Weapon Weapon { get; }
        public Weaver Weaver { get; }
        public WeaponEquippedEventArgs(Weapon weapon, Weaver weaver) {
            Weapon = weapon;
            Weaver = weaver;

        public class WeaponEquippedEventArgs : EventArgs
        {
            public Weapon PreviousWeapon { get; }
            public Weapon CurrentWeapon { get; }
            public Weaver Weaver { get; }
            public WeaponEquippedEventArgs(Weapon previousWeapon, Weapon currentWeapon, Weaver weaver) {
                PreviousWeapon = previousWeapon;
                CurrentWeapon = currentWeapon;
                Weaver = weaver;
            }

    }
    public class CombatFormEquippedEventArgs : EventArgs
    {
        public CombatForm CombatForm { get; }
        public Weaver Weaver { get; }
        public CombatFormEquippedEventArgs(CombatForm combatForm, Weaver weaver) {
            CombatForm = combatForm;
            Weaver = weaver;

        public class CombatFormEquippedEventArgs : EventArgs
        {
            public CombatForm CombatForm { get; }
            public Weaver Weaver { get; }
            public CombatFormEquippedEventArgs(CombatForm combatForm, Weaver weaver) {
                CombatForm = combatForm;
                Weaver = weaver;
            }

    }

    public class TakeActionEventArgs : EventArgs
    {
        public IActionState ActionState { get; }
        public TakeActionEventArgs(IActionState actionState) {
            ActionState = actionState;

        public class TakeActionEventArgs : EventArgs
        {
            public IActionState ActionState { get; }
            public TakeActionEventArgs(IActionState actionState) {
                ActionState = actionState;
            }

}

}

using TagFighter.Effects;

[RequireComponent(typeof(Weaver))]
public class WeaponSwap : MonoBehaviour

namespace TagFighter

    [SerializeField] List<WeaponSet> _weaponSets;
    int _currentActiveSet = -1;
    Weaver _watchedWeaver;

    [RequireComponent(typeof(Weaver))]
    public class WeaponSwap : MonoBehaviour
    {
        [SerializeField] List<WeaponSet> _weaponSets;
        int _currentActiveSet = -1;
        Weaver _watchedWeaver;
        void SetWatchedWeaver(Weaver weaver) {
            if (_watchedWeaver != null) {
                _watchedWeaver.WeaponEquipping -= OnWeaponEquipping;
            }
            _watchedWeaver = weaver;

    void SetWatchedWeaver(Weaver weaver) {
        if (_watchedWeaver != null) {
            _watchedWeaver.WeaponEquipped -= OnWeaponEquipped;

            if (_watchedWeaver != null) {
                _watchedWeaver.WeaponEquipping += OnWeaponEquipping;
            }
        }
        protected void Awake() {
            SetWatchedWeaver(GetComponent<Weaver>());

        _watchedWeaver = weaver;

        protected void OnDestroy() {
            SetWatchedWeaver(null);
        }
        void OnWeaponEquipping(object sender, Weaver.WeaponEquippedEventArgs e) {
            ChangeActiveWeaponSet(e.CurrentWeapon.Name);
            ApplyItemEffects(e.CurrentWeapon);
        }

        if (_watchedWeaver != null) {
            _watchedWeaver.WeaponEquipped += OnWeaponEquipped;

        void ApplyItemEffects(Weapon item) {
            Debug.Log($"ApplyItemEffects on {_watchedWeaver}");
            var context = new EffectContext(new EffectSystem(GameObject.Find("RippleOutVfx").GetComponent<ParticleSystem>())) {
                EffectLocation = _watchedWeaver.transform,
                Caster = _watchedWeaver.transform
            };
            foreach (var effect in item.MainHandEffects()) {
                effect.Mode.ImmediateAction(context, effect.Effect);
            }

    }
    protected void Awake() {
        SetWatchedWeaver(GetComponent<Weaver>());
    }
    protected void OnDestroy() {
        SetWatchedWeaver(null);
    }
    void OnWeaponEquipped(object sender, Weaver.WeaponEquippedEventArgs e) {
        ChangeActiveWeaponSet(e.Weapon.Name);
    }
    void ChangeActiveWeaponSet(string weaponName) {
        var newActiveSet = _weaponSets.FindIndex(set => set.Weapon.Value.Name == weaponName);
        if (newActiveSet == -1) {
            print($"WeaponSwap {weaponName} cannot be found");
            return;
        }
        if (newActiveSet != _currentActiveSet) {
            foreach (var weapon in _weaponSets[newActiveSet].WeaponProps) {
                weapon.SetActive(true);

        void ChangeActiveWeaponSet(string weaponName) {
            var newActiveSet = _weaponSets.FindIndex(set => set.Weapon.Value.Name == weaponName);
            if (newActiveSet == -1) {
                print($"WeaponSwap {weaponName} cannot be found");
                return;

            if (newActiveSet != _currentActiveSet) {
                foreach (var weapon in _weaponSets[newActiveSet].WeaponProps) {
                    weapon.SetActive(true);
                }

            if (_currentActiveSet != -1) {
                foreach (var weapon in _weaponSets[_currentActiveSet].WeaponProps) {
                    weapon.SetActive(false);

                if (_currentActiveSet != -1) {
                    foreach (var weapon in _weaponSets[_currentActiveSet].WeaponProps) {
                        weapon.SetActive(false);
                    }

            }

            _currentActiveSet = newActiveSet;

                _currentActiveSet = newActiveSet;
            }

}

[Serializable]
public class WeaponSet
{
    public WeaponRef Weapon;
    public List<GameObject> WeaponProps;

    [Serializable]
    public class WeaponSet
    {
        public WeaponRef Weapon;
        public List<GameObject> WeaponProps;
    }

[CreateAssetMenu(fileName = "Inventory", menuName = "Combat/Inventory")]
public class Inventory : ScriptableObject

namespace TagFighter

    [SerializeField] List<WeaponRef> _availableWeapons;
    Dictionary<string, Weapon> _availableWeaponsByName;

    [CreateAssetMenu(fileName = "Inventory", menuName = "Combat/Inventory")]
    public class Inventory : ScriptableObject
    {
        [SerializeField] List<WeaponRef> _availableWeapons;
        Dictionary<string, Weapon> _availableWeaponsByName;

    protected void OnEnable() {
        if (_availableWeapons?.Any() == true) {
            _availableWeaponsByName = _availableWeapons.Distinct().ToDictionary(weaponRef => weaponRef.Value.Name, weaponRef => weaponRef.Value);

        protected void OnEnable() {
            if (_availableWeapons?.Any() == true) {
                _availableWeaponsByName = _availableWeapons.Distinct().ToDictionary(weaponRef => weaponRef.Value.Name, weaponRef => weaponRef.Value);
            }

    }

    protected void OnDisable() {
        _availableWeaponsByName?.Clear();
    }

        protected void OnDisable() {
            _availableWeaponsByName?.Clear();
        }

    public bool TryGetWeaponByName(string weaponName, out Weapon weapon) {
        var isWeaponInInventory = false;
        weapon = null;
        if (_availableWeaponsByName != null) {
            isWeaponInInventory = _availableWeaponsByName.TryGetValue(weaponName, out weapon);

        public bool TryGetWeaponByName(string weaponName, out Weapon weapon) {
            var isWeaponInInventory = false;
            weapon = null;
            if (_availableWeaponsByName != null) {
                isWeaponInInventory = _availableWeaponsByName.TryGetValue(weaponName, out weapon);
            }
            return isWeaponInInventory;

        return isWeaponInInventory;

        public IEnumerable<Weapon> GetAvailableWeapons() => _availableWeapons.Select(weaponRef => weaponRef.Value);

    public IEnumerable<Weapon> GetAvailableWeapons() => _availableWeapons.Select(weaponRef => weaponRef.Value);

[RequireComponent(typeof(Weaver))]
public class AnimationManager : MonoBehaviour

namespace TagFighter

    List<string> _idleStatesNames = new();
    string _idleStateName;
    string _runStateName;

    [RequireComponent(typeof(Weaver))]
    public class AnimationManager : MonoBehaviour
    {
        List<string> _idleStatesNames = new();
        string _idleStateName;
        string _runStateName;

    Animator _animator;
    AnimatorOverrideController _animatorOverrideController;
    List<KeyValuePair<AnimationClip, AnimationClip>> _clipOverrides;

        Animator _animator;
        AnimatorOverrideController _animatorOverrideController;
        List<KeyValuePair<AnimationClip, AnimationClip>> _clipOverrides;

    IActionState _currentActionState;
    IActionState _nextActionState;
    int _layer = 0;

        IActionState _currentActionState;
        IActionState _nextActionState;
        int _layer = 0;

    [SerializeField] AnimationClipSetBank _animationBank;
    Dictionary<string, string> _moveToStateMap = new();
    Dictionary<string, float> _animationLengths = new();

        [SerializeField] AnimationClipSetBank _animationBank;
        Dictionary<string, string> _moveToStateMap = new();
        Dictionary<string, float> _animationLengths = new();

    Weaver _watchedWeaver;

        Weaver _watchedWeaver;

    void SetWatchedWeaver(Weaver weaver) {
        if (_watchedWeaver != null) {
            _watchedWeaver.WeaponEquipped -= OnWeaponEquipped;
            _watchedWeaver.ActionTaken -= OnActionTaken;
        }

        void SetWatchedWeaver(Weaver weaver) {
            if (_watchedWeaver != null) {
                _watchedWeaver.WeaponEquipped -= OnWeaponEquipped;
                _watchedWeaver.ActionTaken -= OnActionTaken;
            }

        _watchedWeaver = weaver;

            _watchedWeaver = weaver;

        if (_watchedWeaver != null) {
            _watchedWeaver.WeaponEquipped += OnWeaponEquipped;
            _watchedWeaver.ActionTaken += OnActionTaken;

            if (_watchedWeaver != null) {
                _watchedWeaver.WeaponEquipped += OnWeaponEquipped;
                _watchedWeaver.ActionTaken += OnActionTaken;
            }

    }
    protected void Awake() {
        _animator = GetComponentInChildren<Animator>();
        _currentActionState = default(IdleState);
        _nextActionState = default(IdleState);

        protected void Awake() {
            _animator = GetComponentInChildren<Animator>();
            _currentActionState = default(IdleState);
            _nextActionState = default(IdleState);

        SetWatchedWeaver(GetComponent<Weaver>());
    }
    protected void OnDestroy() {
        SetWatchedWeaver(null);
    }

            SetWatchedWeaver(GetComponent<Weaver>());
        }
        protected void OnDestroy() {
            SetWatchedWeaver(null);
        }

    void OnActionTaken(object sender, Weaver.TakeActionEventArgs e) {
        SetActionState(e.ActionState);
    }

        void OnActionTaken(object sender, Weaver.TakeActionEventArgs e) {
            SetActionState(e.ActionState);
        }

    void OnWeaponEquipped(object sender, Weaver.WeaponEquippedEventArgs e) {
        ChangeClipSet(e.Weapon.Name);
    }

        void OnWeaponEquipped(object sender, Weaver.WeaponEquippedEventArgs e) {
            ChangeClipSet(e.CurrentWeapon.Name);
        }

    void ChangeClipSet(string weaponName) {
        var weaponIdx = _animationBank.AnimationClipSets.FindIndex(set => set.Weapon.Value.Name == weaponName);

        void ChangeClipSet(string weaponName) {
            var weaponIdx = _animationBank.AnimationClipSets.FindIndex(set => set.Weapon.Value.Name == weaponName);

        if (weaponIdx != -1) {
            PopulateAnimations(_animationBank.AnimationClipSets[weaponIdx].ClipSet);
            ResetNextState();
            _idleStateName = GetNewIdleState();
            _animator.Play(_idleStateName, _layer, 0f);

            if (weaponIdx != -1) {
                PopulateAnimations(_animationBank.AnimationClipSets[weaponIdx].ClipSet);
                ResetNextState();
                _idleStateName = GetNewIdleState();
                _animator.Play(_idleStateName, _layer, 0f);
            }

    }

    void PopulateAnimations(AnimationClipSet animationClipSet) {
        _animationLengths.Clear();
        _moveToStateMap.Clear();
        _idleStatesNames.Clear();

        void PopulateAnimations(AnimationClipSet animationClipSet) {
            _animationLengths.Clear();
            _moveToStateMap.Clear();
            _idleStatesNames.Clear();

        _animatorOverrideController = new AnimatorOverrideController(_animator.runtimeAnimatorController);
        _animator.runtimeAnimatorController = _animatorOverrideController;
        _clipOverrides = new List<KeyValuePair<AnimationClip, AnimationClip>>(_animatorOverrideController.overridesCount);
        _animatorOverrideController.GetOverrides(_clipOverrides);

            _animatorOverrideController = new AnimatorOverrideController(_animator.runtimeAnimatorController);
            _animator.runtimeAnimatorController = _animatorOverrideController;
            _clipOverrides = new List<KeyValuePair<AnimationClip, AnimationClip>>(_animatorOverrideController.overridesCount);
            _animatorOverrideController.GetOverrides(_clipOverrides);

        for (var i = 0; i < _clipOverrides.Count; ++i) {
            var clipOverride = _clipOverrides[i];
            var overrideClip = clipOverride.Value;
            // Assuming State name and Clip Key Name are the same 
            var stateName = clipOverride.Key.name;
            if (stateName.Contains("Idle")) {
                if (_idleStatesNames.Count < animationClipSet.Idle.Count) {
                    _idleStatesNames.Add(stateName);
                    overrideClip = animationClipSet.Idle[_idleStatesNames.Count - 1];

            for (var i = 0; i < _clipOverrides.Count; ++i) {
                var clipOverride = _clipOverrides[i];
                var overrideClip = clipOverride.Value;
                // Assuming State name and Clip Key Name are the same 
                var stateName = clipOverride.Key.name;
                if (stateName.Contains("Idle")) {
                    if (_idleStatesNames.Count < animationClipSet.Idle.Count) {
                        _idleStatesNames.Add(stateName);
                        overrideClip = animationClipSet.Idle[_idleStatesNames.Count - 1];
                    }

            }
            else if (stateName.Contains("Run")) {
                _runStateName = stateName;
                overrideClip = animationClipSet.Run;
            }
            else if (stateName.Contains("Attack")) {
                var attackCount = _moveToStateMap.Count;
                if (attackCount < animationClipSet.Attacks.Count) {
                    var moveName = animationClipSet.Attacks[attackCount].CombatMove.Value.MoveName;
                    overrideClip = animationClipSet.Attacks[attackCount].AttackAnimation;
                    _moveToStateMap[moveName] = stateName;
                    _animationLengths[moveName] = overrideClip.length;

                else if (stateName.Contains("Run")) {
                    _runStateName = stateName;
                    overrideClip = animationClipSet.Run;
                }
                else if (stateName.Contains("Attack")) {
                    var attackCount = _moveToStateMap.Count;
                    if (attackCount < animationClipSet.Attacks.Count) {
                        var moveName = animationClipSet.Attacks[attackCount].CombatMove.Value.MoveName;
                        overrideClip = animationClipSet.Attacks[attackCount].AttackAnimation;
                        _moveToStateMap[moveName] = stateName;
                        _animationLengths[moveName] = overrideClip.length;
                    }

                _clipOverrides[i] = new KeyValuePair<AnimationClip, AnimationClip>(_clipOverrides[i].Key, overrideClip);

            _clipOverrides[i] = new KeyValuePair<AnimationClip, AnimationClip>(_clipOverrides[i].Key, overrideClip);

            _animatorOverrideController.ApplyOverrides(_clipOverrides);

        _animatorOverrideController.ApplyOverrides(_clipOverrides);
    }

        void SetActionState(IActionState nextActionState) {
            _nextActionState = nextActionState.IsAdvanced ? nextActionState : default(IdleState);
        }

    void SetActionState(IActionState nextActionState) {
        _nextActionState = nextActionState.IsAdvanced ? nextActionState : default(IdleState);
    }

        void ResetNextState() {
            _nextActionState = default(IdleState);
        }

    void ResetNextState() {
        _nextActionState = default(IdleState);
    }
    void HandleIdleState() {
        switch (_nextActionState) {
            case IdleState:
                if (_animator.GetCurrentAnimatorStateInfo(0).normalizedTime >= 0.99) {
                    var newIdle = GetNewIdleState();
                    if (_idleStateName != newIdle) {
                        _idleStateName = newIdle;
                        _animator.Play(_idleStateName, _layer, 0f);

        void HandleIdleState() {
            switch (_nextActionState) {
                case IdleState:
                    if (_animator.GetCurrentAnimatorStateInfo(0).normalizedTime >= 0.99) {
                        var newIdle = GetNewIdleState();
                        if (_idleStateName != newIdle) {
                            _idleStateName = newIdle;
                            _animator.Play(_idleStateName, _layer, 0f);
                        }

                }
                break;
            case MoveToAction.State:
                _animator.Play(_runStateName, _layer, 0f);
                break;
            case WeaveAction.State weave:
                StartWeave(weave);
                break;

                    break;
                case MoveToAction.State:
                    _animator.Play(_runStateName, _layer, 0f);
                    break;
                case WeaveAction.State weave:
                    StartWeave(weave);
                    break;
            }

    }
    void HandleMoveToState() {
        switch (_nextActionState) {
            case IdleState:
                _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
                _animator.CrossFade(_idleStateName, 0.25f, _layer);
                break;
            case MoveToAction.State:
                break;
            case WeaveAction.State weave:
                StartWeave(weave);
                break;

        void HandleMoveToState() {
            switch (_nextActionState) {
                case IdleState:
                    _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
                    _animator.CrossFade(_idleStateName, 0.25f, _layer);
                    break;
                case MoveToAction.State:
                    break;
                case WeaveAction.State weave:
                    StartWeave(weave);
                    break;

            }

    }

    void HandleWeaveState(WeaveAction.State currentWeave) {
        switch (_nextActionState) {
            case IdleState:
                _animator.Play(_idleStateName, _layer, 0f);
                break;
            case MoveToAction.State:
                _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
                _animator.CrossFade(_runStateName, 0.25f, _layer);
                break;
            case WeaveAction.State weave:
                if (weave.CompletionStatus < 1) {
                    TransitionWeave(currentWeave, weave);
                }
                break;

        void HandleWeaveState(WeaveAction.State currentWeave) {
            switch (_nextActionState) {
                case IdleState:
                    _animator.Play(_idleStateName, _layer, 0f);
                    break;
                case MoveToAction.State:
                    _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
                    _animator.CrossFade(_runStateName, 0.25f, _layer);
                    break;
                case WeaveAction.State weave:
                    if (weave.CompletionStatus < 1) {
                        TransitionWeave(currentWeave, weave);
                    }
                    break;
            }

    }

    void ApplyActionState() {
        switch (_currentActionState) {
            case IdleState:
                HandleIdleState();
                break;
            case MoveToAction.State:
                HandleMoveToState();
                break;
            case WeaveAction.State currentWeave:
                HandleWeaveState(currentWeave);
                break;

        void ApplyActionState() {
            switch (_currentActionState) {
                case IdleState:
                    HandleIdleState();
                    break;
                case MoveToAction.State:
                    HandleMoveToState();
                    break;
                case WeaveAction.State currentWeave:
                    HandleWeaveState(currentWeave);
                    break;
            }
            _currentActionState = _nextActionState;

        _currentActionState = _nextActionState;
    }

    protected void LateUpdate() {
        if (_animator) {
            ApplyActionState();
            ResetNextState();

        protected void LateUpdate() {
            if (_animator) {
                ApplyActionState();
                ResetNextState();
            }

    }

    void StartWeave(WeaveAction.State nextWeave) {
        var moveName = nextWeave.Move.MoveName;
        var moveStateName = _moveToStateMap[moveName];
        _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
        if (_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime > 0.9f) {
            _animator.Play(moveStateName);

        void StartWeave(WeaveAction.State nextWeave) {
            var moveName = nextWeave.Move.MoveName;
            var moveStateName = _moveToStateMap[moveName];
            _animator.Update(-Mathf.Floor(_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime));
            if (_animator.GetCurrentAnimatorStateInfo(_layer).normalizedTime > 0.9f) {
                _animator.Play(moveStateName);
            }
            else {
                _animator.CrossFade(moveStateName, 0.1f, _layer);
            }
            var animationLength = _animationLengths[moveName];
            if (nextWeave.Move.Speed > 0) {
                var desiredSpeed = animationLength / nextWeave.Move.Speed;
                _animator.SetFloat($"Speed", desiredSpeed);
            }

        else {
            _animator.CrossFade(moveStateName, 0.1f, _layer);

        void TransitionWeave(WeaveAction.State currentWeave, WeaveAction.State nextWeave) {
            if (currentWeave.Move != nextWeave.Move) {
                StartWeave(nextWeave);
            }

        var animationLength = _animationLengths[moveName];
        if (nextWeave.Move.Speed > 0) {
            var desiredSpeed = animationLength / nextWeave.Move.Speed;
            _animator.SetFloat($"Speed", desiredSpeed);
        }
    }
    void TransitionWeave(WeaveAction.State currentWeave, WeaveAction.State nextWeave) {
        if (currentWeave.Move != nextWeave.Move) {
            StartWeave(nextWeave);

        string GetNewIdleState() {
            var idleAnimationIndex = Random.Range(0, _idleStatesNames.Count);
            return _idleStatesNames[idleAnimationIndex];

    }

    string GetNewIdleState() {
        var idleAnimationIndex = Random.Range(0, _idleStatesNames.Count);
        return _idleStatesNames[idleAnimationIndex];
    }
    internal readonly struct IdleState : IActionState
    {
        public bool IsAdvanced { get; }
        public float CompletionStatus { get; }
        public bool IsMoving { get; }

        internal readonly struct IdleState : IActionState
        {
            public bool IsAdvanced { get; }
            public float CompletionStatus { get; }
            public bool IsMoving { get; }

        public IdleState(bool isAdvanced, float completionStatus) {
            IsAdvanced = isAdvanced;
            CompletionStatus = completionStatus;
            IsMoving = false;

            public IdleState(bool isAdvanced, float completionStatus) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = false;
            }

}

}

[CreateAssetMenu(fileName = "AnimationClipSetBank", menuName = "RPG/Animation/AnimationClipSetBank")]
public class AnimationClipSetBank : ScriptableObject

namespace TagFighter

    [FormerlySerializedAs("animationClipSets")]
    public List<AnimationClipSetContainer> AnimationClipSets;
}

    [CreateAssetMenu(fileName = "AnimationClipSetBank", menuName = "RPG/Animation/AnimationClipSetBank")]
    public class AnimationClipSetBank : ScriptableObject
    {
        [FormerlySerializedAs("animationClipSets")]
        public List<AnimationClipSetContainer> AnimationClipSets;
    }

[Serializable]
public class AnimationClipSetContainer
{
    [FormerlySerializedAs("weapon")]
    public WeaponRef Weapon;

    [Serializable]
    public class AnimationClipSetContainer
    {
        [FormerlySerializedAs("weapon")]
        public WeaponRef Weapon;

    [FormerlySerializedAs("clipSet")]
    public AnimationClipSet ClipSet;

        [FormerlySerializedAs("clipSet")]
        public AnimationClipSet ClipSet;
    }

using TagFighter.Resources;

public class WeaveAction : IAction

namespace TagFighter

    FollowAction _followAction;
    Transform _target;
    Weaver _weaver;
    RuneWeavingContainer _runeWeaving;
    float _range;
    bool _startedWeaving = false;
    static State s_resetState = new(true, 1f, false, default);

    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;

    public WeaveAction(Weaver unit, RuneWeavingContainer runeWeaving, Transform target, float range) {
        if (range < 0) {
            throw new ArgumentException("Cannot be < 0", "range");

        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;

        _followAction = new(unit, target, range);
        _target = target;
        _range = range;
        _weaver = unit;
        _runeWeaving = runeWeaving;
    }
    public IActionState Advance() {
        var stateToReturn = _followAction.Advance();

        if (IsInAttackRange()) {
            if (_startedWeaving == false) {
                Debug.Log("Target got in range, weaving");

        void OnResourceChanged(object sender, ResourceChangeArgs e) {
            if (_lastRange != e.Current) {
                _followAction.Dispose();
                _followAction = new(_weaver, _target, _range.GetCurrent().ToMeter());
                _lastRange = e.Current;

            _startedWeaving = true;
            var isAdvanced = _runeWeaving.RuneWeaving.Advance(Time.deltaTime);
            stateToReturn = new State(isAdvanced, CompletionStatus(), false, _runeWeaving.RuneWeaving.GetCurrentMove());

        else {
            if (_startedWeaving) {
                Debug.Log("Target escaped");
                stateToReturn = new State(false, CompletionStatus(), stateToReturn.IsMoving, _runeWeaving.RuneWeaving.GetCurrentMove());

        public IActionState Advance() {
            var stateToReturn = _followAction.Advance();
            if (IsInAttackRange()) {
                if (_startedWeaving == false) {
                    Debug.Log("Target got in range, weaving");
                }
                _startedWeaving = true;
                var isAdvanced = _runeWeaving.RuneWeaving.Advance(Time.deltaTime);
                stateToReturn = new State(isAdvanced, CompletionStatus(), false, _runeWeaving.RuneWeaving.GetCurrentMove());
            }
            else {
                if (_startedWeaving) {
                    Debug.Log("Target escaped");
                    stateToReturn = new State(false, CompletionStatus(), stateToReturn.IsMoving, _runeWeaving.RuneWeaving.GetCurrentMove());
                }

            return stateToReturn;

        return stateToReturn;
    }

    public IActionState Cancel() {
        _followAction.Cancel();
        _runeWeaving.RuneWeaving.Reset();

        IActionState Cancel() {
            _runeWeaving.RuneWeaving.Reset();

        return s_resetState;
    }

            return s_resetState;
        }

    public float CompletionStatus() => _runeWeaving.RuneWeaving.CompletionStatus();

        public float CompletionStatus() => _runeWeaving.RuneWeaving.CompletionStatus();

    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;
    }
    public readonly struct State : IActionState
    {
        public bool IsAdvanced { get; }
        public float CompletionStatus { get; }
        public bool IsMoving { get; }

        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 CombatMove Move { get; }

        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 State(bool isAdvanced, float completionStatus, bool isMoving, CombatMove move) {
            IsAdvanced = isAdvanced;
            CompletionStatus = completionStatus;
            IsMoving = isMoving;
            Move = move;

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

}

}

public class MoveToAction : IAction

namespace TagFighter

    Vector3 _lastTargetPosition;
    NavMeshAgent _agent;
    float _originalStoppingDistance;
    float _desiredStoppingDistance;
    bool _isFirstAdvance = true;
    static State s_resetState = new(false, 0f, false);

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

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

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

            _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 (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }

        if (unit.TryGetComponent(out _agent) == false) {
            throw new ArgumentException("Missing NavMeshAgent", "unit");

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

        _lastTargetPosition = target;
        _desiredStoppingDistance = stoppingDistance;
    }
    public bool SetDestination(Vector3 target) {
        _lastTargetPosition = target;
        return _agent.SetDestination(target);
    }
    public IActionState Advance() {
        if (_isFirstAdvance) {
            _originalStoppingDistance = _agent.stoppingDistance;

        public void SetStoppingDistance(float stoppingDistance) {
            if (stoppingDistance < 0) {
                throw new ArgumentException("Cannot be < 0", "stoppingDistance");
            }
            _desiredStoppingDistance = stoppingDistance;

            _agent.isStopped = false;
            _agent.SetDestination(_lastTargetPosition);
            _isFirstAdvance = false;

        var isAdvanced = _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;
        return new State(isAdvanced, CompletionStatus(), isAdvanced);
    }

        public IActionState Advance() {
            if (_isFirstAdvance) {
                _originalStoppingDistance = _agent.stoppingDistance;
                _agent.stoppingDistance = _desiredStoppingDistance;
                _agent.isStopped = false;
                _agent.SetDestination(_lastTargetPosition);
                _isFirstAdvance = false;
            }

    public IActionState Cancel() {
        _agent.isStopped = true;
        _agent.stoppingDistance = _originalStoppingDistance;
        _agent.ResetPath();
        _isFirstAdvance = true;

            var isAdvanced = _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;
            return new State(isAdvanced, CompletionStatus(), isAdvanced);
        }

        return s_resetState;
    }

        IActionState Cancel() {
            _agent.isStopped = true;
            _agent.stoppingDistance = _originalStoppingDistance;
            _agent.ResetPath();
            _isFirstAdvance = true;

    public float CompletionStatus() {
        return 0;
    }
    public override string ToString() {
        return $"Move -> {_lastTargetPosition}";
    }

            return s_resetState;
        }

    public readonly struct State : IActionState
    {
        public bool IsAdvanced { get; }
        public float CompletionStatus { get; }
        public bool IsMoving { get; }

        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;

            public State(bool isAdvanced, float completionStatus, bool isMoving) {
                IsAdvanced = isAdvanced;
                CompletionStatus = completionStatus;
                IsMoving = isMoving;
            }

}

}

public interface IAction
{
    public IActionState Advance();
    public IActionState Cancel();
    public float CompletionStatus();
}

using System;

public interface IActionState

namespace TagFighter

    public bool IsAdvanced { get; }
    public float CompletionStatus { get; }
    public bool IsMoving { get; }

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

public class FollowAction : IAction

namespace TagFighter

    MoveToAction _moveAction;
    Transform _target;
    Vector3 _lastTargetPosition;

    public class FollowAction : IAction
    {
        MoveToAction _moveAction;
        Transform _target;
        Vector3 _lastTargetPosition;
        bool _disposed = false;

    public FollowAction(Weaver unit, Transform target, float stoppingDistance) {
        _target = target ?? throw new ArgumentNullException("targetToFollow");
        _lastTargetPosition = target.position;
        _moveAction = new(unit, _lastTargetPosition, stoppingDistance);
    }
    public IActionState Advance() {
        if (_lastTargetPosition != _target.position) {
            _lastTargetPosition = _target.position;
            _moveAction.SetDestination(_lastTargetPosition);

        public FollowAction(Weaver unit, Transform target) {
            _target = target ?? throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition);

        return _moveAction.Advance();
    }

        public FollowAction(Weaver unit, Transform target, float stoppingDistance) {
            _target = target ?? throw new ArgumentNullException("targetToFollow");
            _lastTargetPosition = target.position;
            _moveAction = new(unit, _lastTargetPosition, stoppingDistance);
        }

    public IActionState Cancel() {
        return _moveAction.Cancel();
    }

        public void SetStoppingDistance(float stoppingDistance) {
            _moveAction.SetStoppingDistance(stoppingDistance);
        }
        public IActionState Advance() {
            if (_lastTargetPosition != _target.position) {
                _lastTargetPosition = _target.position;
                _moveAction.SetDestination(_lastTargetPosition);
            }

    public float CompletionStatus() {
        return 0;
    }
    public override string ToString() {
        return $"Follow {_target.name}";

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

public class TargetIndicator : MonoBehaviour

namespace TagFighter

    [SerializeField] Transform _selectionUI;
    // [SerializeField] float scale = 1.25f;
    Transform _selected;
    [SerializeField] EventAggregator _eventAggregator;

    public class TargetIndicator : MonoBehaviour
    {
        [SerializeField] Transform _selectionUI;
        // [SerializeField] float scale = 1.25f;
        Transform _selected;
        [SerializeField] EventAggregator _eventAggregator;

    protected void Awake() {
        _selectionUI.gameObject.SetActive(false);
    }
    protected void OnDestroy() {
        _eventAggregator.TargetSelected -= OnTargetSelected;
    }
    protected void Update() {
        SetUnitVisual(_selected);
    }
    protected void Start() {
        _eventAggregator.TargetSelected += OnTargetSelected;
    }

        protected void Awake() {
            _selectionUI.gameObject.SetActive(false);
        }
        protected void OnDestroy() {
            _eventAggregator.TargetSelected -= OnTargetSelected;
        }
        protected void Update() {
            SetUnitVisual(_selected);
        }
        protected void Start() {
            _eventAggregator.TargetSelected += OnTargetSelected;
        }

    void OnTargetSelected(object sender, UnitActionEventArgs e) {
        SetSelectedTransform(e.UnitTransform);
    }

        void OnTargetSelected(object sender, UnitActionEventArgs e) {
            SetSelectedTransform(e.UnitTransform);
        }

    void SetSelectedTransform(Transform selected) {
        _selected = selected;
        _selectionUI.gameObject.SetActive(true);
        SetUnitVisual(_selected);
    }

        void SetSelectedTransform(Transform selected) {
            _selected = selected;
            _selectionUI.gameObject.SetActive(true);
            SetUnitVisual(_selected);
        }

    void SetUnitVisual(Transform selected) {
        if (selected) {
            var bounds = selected.GetComponent<Renderer>().bounds;
            transform.position = new Vector3(bounds.center.x, 0, bounds.center.z);
            //this.transform.localScale = new Vector3(bounds.size.x, bounds.size.y, bounds.size.z) * scale;

        void SetUnitVisual(Transform selected) {
            if (selected) {
                var bounds = selected.GetComponent<Renderer>().bounds;
                transform.position = new Vector3(bounds.center.x, 0, bounds.center.z);
                //this.transform.localScale = new Vector3(bounds.size.x, bounds.size.y, bounds.size.z) * scale;
            }

    }

    }

public class SelectionIndicator : MonoBehaviour

namespace TagFighter

    [SerializeField] Transform _selectionUI;
    [SerializeField] EventAggregator _eventAggregator;

    public class SelectionIndicator : MonoBehaviour
    {
        [SerializeField] Transform _selectionUI;
        [SerializeField] EventAggregator _eventAggregator;

    // [SerializeField] float scale = 1.25f;
    Transform _selected;
    protected void Awake() {
        _selectionUI.gameObject.SetActive(false);
    }

        // [SerializeField] float scale = 1.25f;
        Transform _selected;
        protected void Awake() {
            _selectionUI.gameObject.SetActive(false);
        }

    protected void OnDestroy() {
        _eventAggregator.UnitSelected -= OnUnitSelected;
        _eventAggregator.PartyMemberSelected -= OnPartyMemberSelected;
    }
    protected void Update() {
        SetUnitVisual(_selected);
    }
    protected void Start() {
        _eventAggregator.UnitSelected += OnUnitSelected;
        _eventAggregator.PartyMemberSelected += OnPartyMemberSelected;
    }

        protected void OnDestroy() {
            _eventAggregator.UnitSelected -= OnUnitSelected;
            _eventAggregator.PartyMemberSelected -= OnPartyMemberSelected;
        }
        protected void Update() {
            SetUnitVisual(_selected);
        }
        protected void Start() {
            _eventAggregator.UnitSelected += OnUnitSelected;
            _eventAggregator.PartyMemberSelected += OnPartyMemberSelected;
        }

    void OnPartyMemberSelected(object sender, EventAggregator.PartyMemberSelectedEventArgs e) {
        SetSelectedTransform(e.PartyMember.transform);
    }

        void OnPartyMemberSelected(object sender, EventAggregator.PartyMemberSelectedEventArgs e) {
            SetSelectedTransform(e.PartyMember.transform);
        }

    void OnUnitSelected(object sender, UnitActionEventArgs e) {
        SetSelectedTransform(e.UnitTransform);
    }

        void OnUnitSelected(object sender, UnitActionEventArgs e) {
            SetSelectedTransform(e.UnitTransform);
        }

    void SetSelectedTransform(Transform selected) {
        _selected = selected;
        _selectionUI.gameObject.SetActive(true);
        SetUnitVisual(_selected);
    }

        void SetSelectedTransform(Transform selected) {
            _selected = selected;
            _selectionUI.gameObject.SetActive(true);
            SetUnitVisual(_selected);
        }

    void SetUnitVisual(Transform selected) {
        if (selected) {
            var bounds = selected.GetComponent<Renderer>().bounds;
            transform.position = new Vector3(bounds.center.x, 0, bounds.center.z);
            //this.transform.localScale = new Vector3(bounds.size.x, bounds.size.y, bounds.size.z) * scale;

        void SetUnitVisual(Transform selected) {
            if (selected) {
                var bounds = selected.GetComponent<Renderer>().bounds;
                transform.position = new Vector3(bounds.center.x, 0, bounds.center.z);
                //this.transform.localScale = new Vector3(bounds.size.x, bounds.size.y, bounds.size.z) * scale;
            }

            var weaponName = e.Weapon == null ? "" : e.Weapon.Name;

            var weaponName = e.CurrentWeapon == null ? "" : e.CurrentWeapon.Name;

using TagFighter;

public class UnitActionEventArgs : EventArgs

namespace TagFighter

    public Transform UnitTransform { get; }
    public UnitActionEventArgs(Transform unitTransform) {
        UnitTransform = unitTransform;

    public class UnitActionEventArgs : EventArgs
    {
        public Transform UnitTransform { get; }
        public UnitActionEventArgs(Transform unitTransform) {
            UnitTransform = unitTransform;
        }

}

public class UnitMoveEventArgs : EventArgs
{
    public Vector3 Point { get; }
    public UnitMoveEventArgs(Vector3 point) {
        Point = point;

    public class UnitMoveEventArgs : EventArgs
    {
        public Vector3 Point { get; }
        public UnitMoveEventArgs(Vector3 point) {
            Point = point;
        }

}

public class PlayerKeyActions : MonoBehaviour
{
    [SerializeField] CameraController _cameraController;
    [SerializeField] LayerMask _unitSelectionLayerMask;
    [SerializeField] LayerMask _unitMovementLayerMask;
    [SerializeField] EventAggregator _eventAggregator;

    public class PlayerKeyActions : MonoBehaviour
    {
        [SerializeField] CameraController _cameraController;
        [SerializeField] LayerMask _unitSelectionLayerMask;
        [SerializeField] LayerMask _unitMovementLayerMask;
        [SerializeField] EventAggregator _eventAggregator;

    bool _anyGameWorldHidden = false;

        bool _anyGameWorldHidden = false;

    protected void Update() {
        if (_anyGameWorldHidden == false) {
            HandleTimeDilation();
            HandleCameraMovement();
            HandleCameraRotation();
            HandleUnitActions();

        protected void Update() {
            if (_anyGameWorldHidden == false) {
                HandleTimeDilation();
                HandleCameraMovement();
                HandleCameraRotation();
                HandleUnitActions();
            }
            HandleAdditionalKeyboadClicks();
            HandleMouseClick();

        HandleAdditionalKeyboadClicks();
        HandleMouseClick();
    }

    void HandleAdditionalKeyboadClicks() {
        if (Input.GetKeyDown(KeyCode.R)) {
            if (Input.GetKey(KeyCode.LeftControl)) {
                _eventAggregator.OnWeaveBuilderScreenToggleSelected(this, EventArgs.Empty);
                _anyGameWorldHidden = !_anyGameWorldHidden;

        void HandleAdditionalKeyboadClicks() {
            if (Input.GetKeyDown(KeyCode.R)) {
                if (Input.GetKey(KeyCode.LeftControl)) {
                    _eventAggregator.OnWeaveBuilderScreenToggleSelected(this, EventArgs.Empty);
                    _anyGameWorldHidden = !_anyGameWorldHidden;
                }

    }
    void HandleUnitActions() {
    }

        void HandleUnitActions() {
        }

    void HandleMouseClick() {
        if (!EventSystem.current.IsPointerOverGameObject()) {
            if (Input.GetKeyDown(KeyCode.Mouse0)) {
                var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

        void HandleMouseClick() {
            if (!EventSystem.current.IsPointerOverGameObject()) {
                if (Input.GetKeyDown(KeyCode.Mouse0)) {
                    var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                if (Physics.Raycast(ray, out var hit)) {
                    var objectHit = hit.transform;
                    if (_unitSelectionLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                        _eventAggregator.OnUnitSelected(this, new(objectHit));

                    if (Physics.Raycast(ray, out var hit)) {
                        var objectHit = hit.transform;
                        if (_unitSelectionLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                            _eventAggregator.OnUnitSelected(this, new(objectHit));
                        }

            }
            else if (Input.GetKeyDown(KeyCode.Mouse1)) {
                var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                else if (Input.GetKeyDown(KeyCode.Mouse1)) {
                    var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                if (Physics.Raycast(ray, out var hit)) {
                    var objectHit = hit.transform;
                    if (_unitSelectionLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                        _eventAggregator.OnTargetSelected(this, new(objectHit));
                    }
                    else if (_unitMovementLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                        if (Input.GetKey(KeyCode.LeftControl)) {
                            _eventAggregator.OnUnitMove(this, new(hit.point));

                    if (Physics.Raycast(ray, out var hit)) {
                        var objectHit = hit.transform;
                        if (_unitSelectionLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                            _eventAggregator.OnTargetSelected(this, new(objectHit));

                        else {
                            _eventAggregator.OnPlannedActionsClearSelected(this, EventArgs.Empty);
                            _eventAggregator.OnUnitMove(this, new(hit.point));

                        else if (_unitMovementLayerMask.IsLayerInMask(objectHit.gameObject.layer)) {
                            if (Input.GetKey(KeyCode.LeftControl)) {
                                _eventAggregator.OnUnitMove(this, new(hit.point));
                            }
                            else {
                                _eventAggregator.OnPlannedActionsClearSelected(this, EventArgs.Empty);
                                _eventAggregator.OnUnitMove(this, new(hit.point));
                            }

                }

                }

    }

    void HandleTimeDilation() {
        if (Input.GetKeyDown(KeyCode.Period)) {
            _eventAggregator.OnTimeDilationSpeedUp(this, EventArgs.Empty);
        }
        if (Input.GetKeyDown(KeyCode.Comma)) {
            _eventAggregator.OnTimeDilationSpeedDown(this, EventArgs.Empty);
        }
        if (Input.GetKeyDown(KeyCode.Slash)) {
            _eventAggregator.OnTimeDilationSpeedReset(this, EventArgs.Empty);

        void HandleTimeDilation() {
            if (Input.GetKeyDown(KeyCode.Period)) {
                _eventAggregator.OnTimeDilationSpeedUp(this, EventArgs.Empty);
            }
            if (Input.GetKeyDown(KeyCode.Comma)) {
                _eventAggregator.OnTimeDilationSpeedDown(this, EventArgs.Empty);
            }
            if (Input.GetKeyDown(KeyCode.Slash)) {
                _eventAggregator.OnTimeDilationSpeedReset(this, EventArgs.Empty);
            }

    }

        void HandleCameraMovement() {
            if (Input.GetKey(KeyCode.W)) {
                _cameraController.MoveForward();
            }
            if (Input.GetKey(KeyCode.A)) {
                _cameraController.MoveLeft();
            }
            if (Input.GetKey(KeyCode.S)) {
                _cameraController.MoveBack();
            }
            if (Input.GetKey(KeyCode.D)) {
                _cameraController.MoveRight();
            }

    void HandleCameraMovement() {
        if (Input.GetKey(KeyCode.W)) {
            _cameraController.MoveForward();

        if (Input.GetKey(KeyCode.A)) {
            _cameraController.MoveLeft();

        void HandleCameraRotation() {
            if (Input.GetKey(KeyCode.Q)) {
                _cameraController.RotateLeft();
            }
            if (Input.GetKey(KeyCode.E)) {
                _cameraController.RotateRight();
            }

        if (Input.GetKey(KeyCode.S)) {
            _cameraController.MoveBack();
        }
        if (Input.GetKey(KeyCode.D)) {
            _cameraController.MoveRight();
        }

    }

    }
    void HandleCameraRotation() {
        if (Input.GetKey(KeyCode.Q)) {
            _cameraController.RotateLeft();
        }
        if (Input.GetKey(KeyCode.E)) {
            _cameraController.RotateRight();