if (_plannedActions.TryPeek(out IAction action)) {
            IActionState actionState = action.Advance();

        if (_plannedActions.TryPeek(out var action)) {
            var actionState = action.Advance();

                _plannedActions.TryGetFirstOutOfLine(out IAction _);

                _plannedActions.TryGetFirstOutOfLine(out var _);

        bool success = false;

        var success = false;

        if (_plannedActions.TryPeek(out IAction currentAction)) {

        if (_plannedActions.TryPeek(out var currentAction)) {

        _preferedCombatFormByWeapon.TryGetValue(weapon, out CombatForm tryEquipForm);

        _preferedCombatFormByWeapon.TryGetValue(weapon, out var tryEquipForm);

        var TryEquipWeapon = _inventory.GetAvailableWeapons().First();
        if (TryEquipWeapon != null) {
            TryDrawWeapon(TryEquipWeapon.name);

        var tryEquipWeapon = _inventory.GetAvailableWeapons().First();
        if (tryEquipWeapon != null) {
            TryDrawWeapon(tryEquipWeapon.name);

        bool isWeaponInInventory = false;

        var isWeaponInInventory = false;

            isWeaponInInventory = _inventory.TryGetWeaponByName(weaponName, out Weapon tryEquipWeapon);

            isWeaponInInventory = _inventory.TryGetWeaponByName(weaponName, out var tryEquipWeapon);

        bool success = PlanAction(weaveAction);

        var success = PlanAction(weaveAction);

        bool success = PlanAction(followAction);

        var success = PlanAction(followAction);

        bool success = PlanAction(moveToAction);

        var success = PlanAction(moveToAction);

    public bool TryRemoveActionFromPlan(int Index) {
        bool success = false;
        if (_plannedActions.TryRemoveAt(Index, out IAction _)) {

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

        int newActiveSet = _weaponSets.FindIndex(set => set.weapon.Value.name == weaponName);

        var newActiveSet = _weaponSets.FindIndex(set => set.weapon.Value.name == weaponName);

    Dictionary<String, Weapon> _availableWeaponsByName;

    Dictionary<string, Weapon> _availableWeaponsByName;

        if (_availableWeaponsByName != null) {
            _availableWeaponsByName.Clear();
        }

        _availableWeaponsByName?.Clear();

        bool isWeaponInInventory = false;

        var isWeaponInInventory = false;

        int weaponIdx = _animationBank.animationClipSets.FindIndex(set => set.weapon.Value.name == weaponName);

        var weaponIdx = _animationBank.animationClipSets.FindIndex(set => set.weapon.Value.name == weaponName);

        for (int i = 0; i < _clipOverrides.Count; ++i) {

        for (var i = 0; i < _clipOverrides.Count; ++i) {

            AnimationClip overrideClip = clipOverride.Value;

            var overrideClip = clipOverride.Value;

                    string newIdle = GetNewIdleState();

                    var newIdle = GetNewIdleState();

        string moveStateName = _moveToStateMap[moveName];

        var moveStateName = _moveToStateMap[moveName];

        float animationLength = _animationLengths[moveName];

        var animationLength = _animationLengths[moveName];

            float desiredSpeed = animationLength / nextWeave.Move.speed;

            var desiredSpeed = animationLength / nextWeave.Move.speed;

        int idleAnimationIndex = Random.Range(0, _idleStatesNames.Count);

        var idleAnimationIndex = Random.Range(0, _idleStatesNames.Count);

    readonly internal struct IdleState : IActionState

    internal readonly struct IdleState : IActionState

    static State resetState = new(true, 1f, false, default);

    static State s_resetState = new(true, 1f, false, default);

        IActionState stateToReturn = _followAction.Advance();

        var stateToReturn = _followAction.Advance();

            bool isAdvanced = _runeWeaving.runeWeaving.Advance(Time.deltaTime);

            var isAdvanced = _runeWeaving.runeWeaving.Advance(Time.deltaTime);

        
        return resetState;

        return s_resetState;

    readonly public struct State : IActionState

    public readonly struct State : IActionState

    static State resetState = new(false, 0f, false);

    static State s_resetState = new(false, 0f, false);

        bool isAdvanced = _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;

        var isAdvanced = _agent.pathPending || _agent.remainingDistance > _agent.stoppingDistance;

        return resetState;

        return s_resetState;

    readonly public struct State : IActionState

    public readonly struct State : IActionState

            bool addedToBank = false;
            if (ValidWeaveName.TryParse(weaveName.text, out ValidWeaveName validWeaveName)) {

            var addedToBank = false;
            if (ValidWeaveName.TryParse(weaveName.text, out var validWeaveName)) {

                GameObject timeNodeToRemove = _timeSequenceNodes[^1];

                var timeNodeToRemove = _timeSequenceNodes[^1];

                GameObject timeNode = Instantiate(TimeCounterNodeTemplate, TimeCounterTransform);
                TextMeshProUGUI secLabel = timeNode.GetComponentInChildren<TextMeshProUGUI>();

                var timeNode = Instantiate(TimeCounterNodeTemplate, TimeCounterTransform);
                var secLabel = timeNode.GetComponentInChildren<TextMeshProUGUI>();

            GameObject combatMoveNode = Instantiate(MartialSequenceNodeTemplate, MartialSequenceTransform);
            TextMeshProUGUI nameLabel = combatMoveNode.GetComponentInChildren<TextMeshProUGUI>();
            MartialSequenceClicker martialSequenceClicker = combatMoveNode.GetComponent<MartialSequenceClicker>();
            RectTransform combatMoveNodeNodeTransform = combatMoveNode.GetComponent<RectTransform>();

            var combatMoveNode = Instantiate(MartialSequenceNodeTemplate, MartialSequenceTransform);
            var nameLabel = combatMoveNode.GetComponentInChildren<TextMeshProUGUI>();
            var martialSequenceClicker = combatMoveNode.GetComponent<MartialSequenceClicker>();
            var combatMoveNodeNodeTransform = combatMoveNode.GetComponent<RectTransform>();

            MartialSequenceClicker martialSequenceClicker = _martialSequence[positionInSequence];

            var martialSequenceClicker = _martialSequence[positionInSequence];

            GameObject runeBindingNode = Instantiate(RuneBindingSequenceNodeTemplate, RuneBindingSequenceTransform);
            TextMeshProUGUI nameLabel = runeBindingNode.GetComponentInChildren<TextMeshProUGUI>();
            RuneBindingSequenceClicker runeBindingSequenceClicker = runeBindingNode.GetComponent<RuneBindingSequenceClicker>();
            RectTransform runeBindingNodeTransform = runeBindingNode.GetComponent<RectTransform>();

            var runeBindingNode = Instantiate(RuneBindingSequenceNodeTemplate, RuneBindingSequenceTransform);
            var nameLabel = runeBindingNode.GetComponentInChildren<TextMeshProUGUI>();
            var runeBindingSequenceClicker = runeBindingNode.GetComponent<RuneBindingSequenceClicker>();
            var runeBindingNodeTransform = runeBindingNode.GetComponent<RectTransform>();

            RuneBindingSequenceClicker runeBindingSequenceClicker = _runeBindingSequence[positionInSequence];

            var runeBindingSequenceClicker = _runeBindingSequence[positionInSequence];

            int positionInSequence = _martialSequence.IndexOf(clicker);
            bool moveRemovedFromSequence = false;

            var positionInSequence = _martialSequence.IndexOf(clicker);
            var moveRemovedFromSequence = false;

            bool moveAddedToSequence = false;

            var moveAddedToSequence = false;

            int positionInSequence = _runeBindingSequence.IndexOf(clicker);
            bool runeRemovedFromSequence = false;

            var positionInSequence = _runeBindingSequence.IndexOf(clicker);
            var runeRemovedFromSequence = false;

            bool runeAddedToSequence = false;

            var runeAddedToSequence = false;

            if (ValidWeaveName.TryParse(weavePicker.options[weavePicker.value].text, out ValidWeaveName validWeaveName)) {
                if (runeWeavingBank.TryGetWeaveByName(validWeaveName, out RuneWeavingContainer runeWeavingContainer)) {

            if (ValidWeaveName.TryParse(weavePicker.options[weavePicker.value].text, out var validWeaveName)) {
                if (runeWeavingBank.TryGetWeaveByName(validWeaveName, out var runeWeavingContainer)) {

            bool deletedFromBank = false;
            if (ValidWeaveName.TryParse(weavePicker.options[weavePicker.value].text, out ValidWeaveName validWeaveName)) {

            var deletedFromBank = false;
            if (ValidWeaveName.TryParse(weavePicker.options[weavePicker.value].text, out var validWeaveName)) {

            eventAggregator.WeaveBuilderScreenToggleSelected -= OnWeaveBuilderScreenToggleSelected;            

            eventAggregator.WeaveBuilderScreenToggleSelected -= OnWeaveBuilderScreenToggleSelected;

            string selectedWeaponName = change.options[change.value].text;

            var selectedWeaponName = change.options[change.value].text;

        readonly List<RuneClicker> gridItems = new();

        readonly List<RuneClicker> _gridItems = new();

                GameObject runeImageObject = Instantiate(runeImagePrefab, transform);

                var runeImageObject = Instantiate(runeImagePrefab, transform);

                    gridItems.Add(runeClicker);

                    _gridItems.Add(runeClicker);

            if (gridItems.Count > 0) {

            if (_gridItems.Count > 0) {

                if (gridItems[_currentSelectedGridLocation].TryGetComponent<Outline>(out outline)) {

                if (_gridItems[_currentSelectedGridLocation].TryGetComponent<Outline>(out outline)) {

            if (gridItems[_currentSelectedGridLocation].TryGetComponent<Outline>(out outline)) {

            if (_gridItems[_currentSelectedGridLocation].TryGetComponent<Outline>(out outline)) {

        Image currentSelected;

        Image _currentSelected;

            CombatMoveSet formedMoveSet = combatForm.FormedMoveSet(weapon.GetCombatMoveSetRef());

            var formedMoveSet = combatForm.FormedMoveSet(weapon.GetCombatMoveSetRef());

                GameObject movePickUIObject = Instantiate(MovePickUIPrefab, Content);
                TextMeshProUGUI moveNameLabel = movePickUIObject.GetComponentInChildren<TextMeshProUGUI>();

                var movePickUIObject = Instantiate(MovePickUIPrefab, Content);
                var moveNameLabel = movePickUIObject.GetComponentInChildren<TextMeshProUGUI>();

            if (currentSelected != null) {
                currentSelected.color = Color.white;

            if (_currentSelected != null) {
                _currentSelected.color = Color.white;

            if (moveClicker.TryGetComponent(out currentSelected)) {
                currentSelected.color = Color.green;

            if (moveClicker.TryGetComponent(out _currentSelected)) {
                _currentSelected.color = Color.green;

        TMP_Dropdown _CombatFormDropDown;

        TMP_Dropdown _combatFormDropDown;

            _CombatFormDropDown = GetComponent<TMP_Dropdown>();
            _CombatFormDropDown.onValueChanged.AddListener(delegate {
                CombatFormDropDownValueChanged(_CombatFormDropDown);

            _combatFormDropDown = GetComponent<TMP_Dropdown>();
            _combatFormDropDown.onValueChanged.AddListener(delegate {
                CombatFormDropDownValueChanged(_combatFormDropDown);

            _CombatFormDropDown.ClearOptions();
            _CombatFormDropDown.AddOptions(

            _combatFormDropDown.ClearOptions();
            _combatFormDropDown.AddOptions(

                .Select(CombatForm => new TMP_Dropdown.OptionData(CombatForm.name))

                .Select(combatForm => new TMP_Dropdown.OptionData(combatForm.name))

            CombatFormDropDownValueChanged(_CombatFormDropDown);

            CombatFormDropDownValueChanged(_combatFormDropDown);

            string selectedCombatFormName = change.options[change.value].text;

            var selectedCombatFormName = change.options[change.value].text;

            Bounds bounds = selected.GetComponent<Renderer>().bounds;

            var bounds = selected.GetComponent<Renderer>().bounds;

            Bounds bounds = selected.GetComponent<Renderer>().bounds;

            var bounds = selected.GetComponent<Renderer>().bounds;

using TagFighter.Resources;

            Vector3 dirToCamera = (_camera.position - transform.position).normalized;

            var dirToCamera = (_camera.position - transform.position).normalized;

            string weaponName = e.Weapon == null ? "" : e.Weapon.name;

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

            for (int i = 0; i < PlannedActionsUI.Count(); ++i) {

            for (var i = 0; i < PlannedActionsUI.Count(); ++i) {

            int count = 0;

            var count = 0;

                Transform partyMemberPortraitTransform = Instantiate(partyMemberUnitFrame, transform);
                PartyMemberPortrait partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();

                var partyMemberPortraitTransform = Instantiate(partyMemberUnitFrame, transform);
                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();

                ResourceWatcher[] partyMemberResources = partyMemberPortraitTransform.GetComponentsInChildren<ResourceWatcher>();

                var partyMemberResources = partyMemberPortraitTransform.GetComponentsInChildren<ResourceWatcher>();

                PartyMemberPortrait partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();

                var partyMemberPortrait = partyMemberPortraitTransform.GetComponentInChildren<PartyMemberPortrait>();

            string combatFormName = e.CombatForm == null ? "" : e.CombatForm.name;

            var combatFormName = e.CombatForm == null ? "" : e.CombatForm.name;

using System;

            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

            if (Physics.Raycast(ray, out RaycastHit hit)) {
                Transform objectHit = hit.transform;

            if (Physics.Raycast(ray, out var hit)) {
                var objectHit = hit.transform;

            float currentTimeScale = Time.timeScale;
            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            float currentTimeScale = Time.timeScale;
            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            var currentTimeScale = Time.timeScale;
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            bool anyFail = false;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var anyFail = false;

            foreach (int item in insertArr) {

            foreach (var item in insertArr) {

            if (!l.TryGetFirstOutOfLine(out int n) || (n != insertArr[0])) {

            if (!l.TryGetFirstOutOfLine(out var n) || (n != insertArr[0])) {

            int count = 1;

            var count = 1;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            bool anyFail = false;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var anyFail = false;

            foreach (int item in insertArr) {

            foreach (var item in insertArr) {

            int insert = 6;

            var insert = 6;

            if (!l.TryGetFirstOutOfLine(out int n) || (n != insert)) {

            if (!l.TryGetFirstOutOfLine(out var n) || (n != insert)) {

            int count = 0;

            var count = 0;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            bool anyFail = false;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var anyFail = false;

            foreach (int item in insertArr) {

            foreach (var item in insertArr) {

            int position = 2;
            if (!l.TryRemoveAt(position, out int n) || n != insertArr[position]) {

            var position = 2;
            if (!l.TryRemoveAt(position, out var n) || n != insertArr[position]) {

            int count = 0;

            var count = 0;

            string testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            bool anyFail = false;

            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var anyFail = false;

            l.TryGetFirstOutOfLine(out int _);
            l.TryGetFirstOutOfLine(out int _);

            l.TryGetFirstOutOfLine(out var _);
            l.TryGetFirstOutOfLine(out var _);

            int count = 0;

            var count = 0;

                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                if (Physics.Raycast(ray, out RaycastHit hit)) {
                    Transform objectHit = hit.transform;

                if (Physics.Raycast(ray, out var hit)) {
                    var objectHit = hit.transform;

                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                if (Physics.Raycast(ray, out RaycastHit hit)) {
                    Transform objectHit = hit.transform;

                if (Physics.Raycast(ray, out var hit)) {
                    var objectHit = hit.transform;

    public interface IUnit {}

    public interface IUnit { }

    public struct Unit<TUnitType> : IUnit, IEquatable<Unit<TUnitType>>, IComparable<Unit<TUnitType>>  where TUnitType : IUnitType

    public struct Unit<TUnitType> : IUnit, IEquatable<Unit<TUnitType>>, IComparable<Unit<TUnitType>> where TUnitType : IUnitType

        public int AsPrimitive() => _value; 

        public int AsPrimitive() => _value;

using TagFighter.Resources;
using UnityEngine;

using TagFighter.Resources;
using UnityEngine;

        static readonly OnChangeArgs Default = new(0, 1, null);

        static readonly OnChangeArgs s_default = new(0, 1, null);

        SerializableType  _watch;

        SerializableType _watch;

                OnChangeArgs status = Default;

                var status = s_default;

                WatchedResource = GetComponentInParent(_watch.Type) is IWatchableResource resource ? resource : null; 

                WatchedResource = GetComponentInParent(_watch.Type) is IWatchableResource resource ? resource : null;

    public interface IAccessibleResource<TUnitType> where TUnitType : IUnitType  {

    public interface IAccessibleResource<TUnitType> where TUnitType : IUnitType
    {

            float timeToWait = (float)(expiryTime - Time.timeAsDouble);

            var timeToWait = (float)(expiryTime - Time.timeAsDouble);

            return new( (int)resource.GetCurrent(), (int)resource.GetCapacity(), resource.transform);

            return new((int)resource.GetCurrent(), (int)resource.GetCapacity(), resource.transform);

        public Transform Pawn{ get; }

        public Transform Pawn { get; }

using UnityEngine;

using UnityEngine;

    class EffectRunner : MonoBehaviour {

    class EffectRunner : MonoBehaviour
    {

        public Material Material; 

        public Material Material;

            Material.SetFloat("_Phase", 0);           

            Material.SetFloat("_Phase", 0);

                    float totalTime = 0;

            float totalTime = 0;

            
            while (phase < 0.98)
            {

            while (phase < 0.98) {

                Material.SetFloat("_Phase", phase);           

                Material.SetFloat("_Phase", phase);

            case SingleTarget _: ApplyTagsEffectSingle(tags, origin); break;

            case SingleTarget: ApplyTagsEffectSingle(tags, origin); break;

        Debug.Log("AppalyTagsEffectSingle");

        Debug.Log("ApplyTagsEffectSingle");

         var color = GetEffectColor(tags);
        

        var color = GetEffectColor(tags);

        Material material = new (Resources.Load<Material>(PulseMaterial));

        Material material = new(Resources.Load<Material>(PulseMaterial));

        Material material = new (Resources.Load<Material>(PulseMaterial));

        Material material = new(Resources.Load<Material>(PulseMaterial));

        Material material = new (Resources.Load<Material>(PulseMaterial));

        Material material = new(Resources.Load<Material>(PulseMaterial));

        float total = tags[TagColor.Red] + tags[TagColor.Green] + tags[TagColor.Blue];
        float red = tags[TagColor.Red] / total;
        float green = tags[TagColor.Green] / total;
        float blue = tags[TagColor.Blue] / total;

        var total = tags[TagColor.Red] + tags[TagColor.Green] + tags[TagColor.Blue];
        var red = tags[TagColor.Red] / total;
        var green = tags[TagColor.Green] / total;
        var blue = tags[TagColor.Blue] / total;

        Color color = new (red, green, blue);

        Color color = new(red, green, blue);

    private void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh,  Material material) {
        GameObject effectObj = new ();

    private void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh, Material material) {
        GameObject effectObj = new();

        MeshRenderer meshRenderer = effectObj.AddComponent<MeshRenderer>();

        var meshRenderer = effectObj.AddComponent<MeshRenderer>();

        MeshFilter meshFilter = effectObj.AddComponent<MeshFilter>();

        var meshFilter = effectObj.AddComponent<MeshFilter>();

        EffectRunner effectRunner = effectObj.GetComponent<EffectRunner>();

        var effectRunner = effectObj.GetComponent<EffectRunner>();

        Mesh mesh = new ();
 
        int n = numberOfVerticesInArc + 1;
       

        Mesh mesh = new();
        var n = numberOfVerticesInArc + 1;

        float arcStep = arc / (n-2);
        float currentDegrees = -arc / 2; 

        var arcStep = arc / (n - 2);
        var currentDegrees = -arc / 2;

        Vector3[] vertices = new Vector3[n];
        Vector2[] uv = new Vector2[n];

        var vertices = new Vector3[n];
        var uv = new Vector2[n];

        uv[0]  = origin;

        uv[0] = origin;

        for (int i = 1; i < n; i++) {

        for (var i = 1; i < n; i++) {

            uv[i]  = new Vector2(0, 1);

            uv[i] = new Vector2(0, 1);

            currentDegrees+= arcStep;

            currentDegrees += arcStep;

        int[] tris = new int[(n-2) * 3];
        for (int i = 0; i < n - 2; i++) {

        var tris = new int[(n - 2) * 3];
        for (var i = 0; i < n - 2; i++) {

        Vector3[] normals = new Vector3[n];
         for (int i = 0; i < n; i++) {
            normals[i] =  rotationAxis;

        var normals = new Vector3[n];
        for (var i = 0; i < n; i++) {
            normals[i] = rotationAxis;

        Mesh mesh = new ();

        Mesh mesh = new();

        Vector3[] vertices = new Vector3[4]

        var vertices = new Vector3[4]

        int[] tris = new int[6]

        var tris = new int[6]

        Vector3[] normals = new Vector3[4]

        var normals = new Vector3[4]

        Vector2[] uv = new Vector2[4]

        var uv = new Vector2[4]

            using IEnumerator<T> en = collection.GetEnumerator();

            using var en = collection.GetEnumerator();

            bool success = false;

            var success = false;

            bool success = false;

            var success = false;

            bool success = false;

            var success = false;

            for (int currentPosition = position; currentPosition < _count - 1; currentPosition++) {

            for (var currentPosition = position; currentPosition < _count - 1; currentPosition++) {

            bool success = false;

            var success = false;

            int numToCopy = Math.Clamp(_count, Capacity - index, _count);

            var numToCopy = Math.Clamp(_count, Capacity - index, _count);

                int firstPart = (Capacity - _head < numToCopy) ? Capacity - _head : numToCopy;

                var firstPart = (Capacity - _head < numToCopy) ? Capacity - _head : numToCopy;

        bool unregistered = false;

        var unregistered = false;

        bool registered = false;

        var registered = false;

    public float dilationStep = 0.25f;

    public float _dilationStep = 0.25f;

    private float baseTimeScale;

    private float _baseTimeScale;

        baseTimeScale = Time.timeScale;

        _baseTimeScale = Time.timeScale;

        Time.timeScale = baseTimeScale;

        Time.timeScale = _baseTimeScale;

        Time.timeScale = MathF.Max(MinTimeDilation, MathF.Round(Time.timeScale - dilationStep, TimeDilationPercision));

        Time.timeScale = MathF.Max(MinTimeDilation, MathF.Round(Time.timeScale - _dilationStep, TimeDilationPercision));

        Time.timeScale = MathF.Min(MaxTimeDilation, MathF.Round(Time.timeScale + dilationStep, TimeDilationPercision));

        Time.timeScale = MathF.Min(MaxTimeDilation, MathF.Round(Time.timeScale + _dilationStep, TimeDilationPercision));

    public float CurrentTime {get; set;}
    public float LastTime {get; set;}

    public float CurrentTime { get; set; }
    public float LastTime { get; set; }

    public int CurrentIdx {get; set;}

    public int CurrentIdx { get; set; }

    public EffectContext Context {get; set;}

    public EffectContext Context { get; set; }

using UnityEngine;

using UnityEngine;

        bool found = false;
        int weaveIndex = runeWeavings.FindIndex(weave => weave.weaveName == weaveName);

        var found = false;
        var weaveIndex = runeWeavings.FindIndex(weave => weave.weaveName == weaveName);

        bool found = false;
        int weaveIndex = runeWeavings.FindIndex(weave => weave.weaveName == weaveName);

        var found = false;
        var weaveIndex = runeWeavings.FindIndex(weave => weave.weaveName == weaveName);

    public void OnAfterDeserialize() {
            
    }

        bool validName = IsWeaveNameValid(weaveName);

        var validName = IsWeaveNameValid(weaveName);

        bool validName = IsWeaveNameValid(weaveName);

        var validName = IsWeaveNameValid(weaveName);

        bool isAdvanced = martialSequence.Advance(deltaTime);

        var isAdvanced = martialSequence.Advance(deltaTime);

        } 

        }

   public TaggableUnit unit;
   public IEnumerable<TagSlot> change;

    public TaggableUnit unit;
    public IEnumerable<TagSlot> change;

            TaggableUnit taggableUnit = unit.GetComponent<TaggableUnit>();

            var taggableUnit = unit.GetComponent<TaggableUnit>();

                var eventArgs = new TagsChangedEventArgs{unit = taggableUnit, change = tags};
                if (_eventAggregator != null) {
                    _eventAggregator.OnTagsChanged(this, eventArgs);
                }

                var eventArgs = new TagsChangedEventArgs { unit = taggableUnit, change = tags };
                _eventAggregator?.OnTagsChanged(this, eventArgs);

            bool isValidEnum = Enum.TryParse(colorName, out TagColor color);

            var isValidEnum = Enum.TryParse(colorName, out TagColor color);

            bool isValidEnum = Enum.TryParse(colorName, out TagColor color);

            var isValidEnum = Enum.TryParse(colorName, out TagColor color);

            int slotNum = (int)(color);

            var slotNum = (int)(color);

            int slotNum = (int)(color);

            var slotNum = (int)(color);

using CareBoo.Serially;

using CareBoo.Serially;

            effect.Mode.ImmediateAction(context,effect.Effect);

            effect.Mode.ImmediateAction(context, effect.Effect);

    public interface IResourceLocationAccessor {}

    public interface IResourceLocationAccessor { }

            int current = Resource.GetStat(e.Pawn, Stat);

            var current = Resource.GetStat(e.Pawn, Stat);

using UnityEngine;

using UnityEngine;

    public class EffectInput {

    public class EffectInput
    {

            Quaternion direction = Quaternion.LookRotation(directionVector, Vector3.up);
            
            data.Context.EffectSystem.ApplyTagsEffect(c, data.Context.EffectLocation, direction , data.Context.AreaOfEffect);

            var direction = Quaternion.LookRotation(directionVector, Vector3.up);
            data.Context.EffectSystem.ApplyTagsEffect(c, data.Context.EffectLocation, direction, data.Context.AreaOfEffect);

                  // direction towards target

                // direction towards target

                Quaternion direction = Quaternion.LookRotation(directionVector, Vector3.up);

                var direction = Quaternion.LookRotation(directionVector, Vector3.up);

                GameObject tmpGo = new ();

                GameObject tmpGo = new();

            Quaternion direction = Quaternion.LookRotation(directionVector, Vector3.up);

            var direction = Quaternion.LookRotation(directionVector, Vector3.up);

            GameObject tmpGo = new ();

            GameObject tmpGo = new();

        RaycastHit[] hits = Physics.SphereCastAll(origin.position, Radius, origin.forward, 0, LayerMask.NameToLayer("units"));

        var hits = Physics.SphereCastAll(origin.position, Radius, origin.forward, 0, LayerMask.NameToLayer("units"));

        RaycastHit[] possibleHits = Physics.SphereCastAll(origin.position, Radius, origin.forward, 0, LayerMask.NameToLayer("units"));
      

        var possibleHits = Physics.SphereCastAll(origin.position, Radius, origin.forward, 0, LayerMask.NameToLayer("units"));

            return targetAngle <= Angle/2;

            return targetAngle <= Angle / 2;

        var hits = Physics.BoxCastAll(origin.position, new Vector3(Width/2, 0 , 0), origin.forward, origin.rotation, Length, LayerMask.NameToLayer("units"));

        var hits = Physics.BoxCastAll(origin.position, new Vector3(Width / 2, 0, 0), origin.forward, origin.rotation, Length, LayerMask.NameToLayer("units"));

using TagFighter.Resources;

        public ResourceInfoGet<IResourceTypeAccessor,IResourceLocationGet> From;
        public ResourceInfoSet<IResourceTypeAccessor,IResourceLocationSet> To;

        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> From;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;

            string _effectName = $"UnaryEffect ({From}) To ({To})";

            var effectName = $"UnaryEffect ({From}) To ({To})";

            Debug.Log($"{_effectName} : Apply");

            Debug.Log($"{effectName} : Apply");

        public ResourceInfoGet<IResourceTypeAccessor,IResourceLocationGet> FromA;
        public ResourceInfoGet<IResourceTypeAccessor,IResourceLocationGet> FromB;
        public ResourceInfoSet<IResourceTypeAccessor,IResourceLocationSet> To;

        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromA;
        public ResourceInfoGet<IResourceTypeAccessor, IResourceLocationGet> FromB;
        public ResourceInfoSet<IResourceTypeAccessor, IResourceLocationSet> To;

            string _effectName = $"BinaryEffect({FromA} {Operator} {FromB})To({To})";

            var effectName = $"BinaryEffect({FromA} {Operator} {FromB})To({To})";

                Debug.Log($"{_effectName}: Apply missing operator, skipping");

                Debug.Log($"{effectName}: Apply missing operator, skipping");

            Debug.Log($"{_effectName} : Apply");

            Debug.Log($"{effectName} : Apply");

using System.Collections;

using System;

using System;
using System.Linq;

public class Weapon 

public class Weapon

using System.Collections;

using System.Linq;

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

        if (combatForm != null) {
            combatForm.Populate();
        }

        combatForm?.Populate();

        if (combatForm != null) {
            combatForm.Clear();
        }

        combatForm?.Clear();

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using UnityEngine;

    private CombatMoveSet combatMoveSet;

    private CombatMoveSet _combatMoveSet;

            combatMoveSet = combatMoveSetRef;

            _combatMoveSet = combatMoveSetRef;

        combatMoveSet = null;

        _combatMoveSet = null;

        return formedMoveSet.AddMoves(moveSet.CombatMoves().Select(move => FormMove(move))).AddMoves(combatMoveSet);

        return formedMoveSet.AddMoves(moveSet.CombatMoves().Select(move => FormMove(move))).AddMoves(_combatMoveSet);

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

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

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

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

# EditorConfig is awesome: https://EditorConfig.org
# top-most EditorConfig file
root = true
# Don't use tabs for indentation.
[*]
indent_style = space
# (Please don't specify an indent_size here; that has too many unintended consequences.)
# Code files
[*.{cs,csx,vb,vbx}]
indent_size = 4
insert_final_newline = true
charset = utf-8-bom
# XML project files
[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
indent_size = 2
# XML config files
[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}]
indent_size = 2
# JSON files
[*.json]
indent_size = 2
# Powershell files
[*.ps1]
indent_size = 2
# Shell script files
[*.sh]
end_of_line = lf
indent_size = 2
# Dotnet code style settings:
[*.{cs,vb}]
# IDE0055: Fix formatting
dotnet_diagnostic.IDE0055.severity = warning
# Sort using and Import directives with System.* appearing first
dotnet_sort_system_directives_first = true
dotnet_separate_import_directive_groups = false
# Avoid "this." and "Me." if not necessary
dotnet_style_qualification_for_field = false:refactoring
dotnet_style_qualification_for_property = false:refactoring
dotnet_style_qualification_for_method = false:refactoring
dotnet_style_qualification_for_event = false:refactoring
# Use language keywords instead of framework type names for type references
dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
dotnet_style_predefined_type_for_member_access = true:suggestion
# Suggest more modern language features when available
dotnet_style_object_initializer = true:suggestion
dotnet_style_collection_initializer = true:suggestion
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_explicit_tuple_names = true:suggestion
# Whitespace options
dotnet_style_allow_multiple_blank_lines_experimental = false
# Non-private static fields are PascalCase
dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style
dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field
dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected
dotnet_naming_symbols.non_private_static_fields.required_modifiers = static
dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case
# Non-private readonly fields are PascalCase
dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.symbols = non_private_readonly_fields
dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.style = non_private_readonly_field_style
dotnet_naming_symbols.non_private_readonly_fields.applicable_kinds = field
dotnet_naming_symbols.non_private_readonly_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected
dotnet_naming_symbols.non_private_readonly_fields.required_modifiers = readonly
dotnet_naming_style.non_private_readonly_field_style.capitalization = pascal_case
# Constants are PascalCase
dotnet_naming_rule.constants_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants
dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style
dotnet_naming_symbols.constants.applicable_kinds = field, local
dotnet_naming_symbols.constants.required_modifiers = const
dotnet_naming_style.constant_style.capitalization = pascal_case
# Static fields are camelCase and start with s_
dotnet_naming_rule.static_fields_should_be_camel_case.severity = suggestion
dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields
dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style
dotnet_naming_symbols.static_fields.applicable_kinds = field
dotnet_naming_symbols.static_fields.required_modifiers = static
dotnet_naming_style.static_field_style.capitalization = camel_case
dotnet_naming_style.static_field_style.required_prefix = s_
# Instance fields are camelCase and start with _
dotnet_naming_rule.instance_fields_should_be_camel_case.severity = suggestion
dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields
dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style
dotnet_naming_symbols.instance_fields.applicable_kinds = field
dotnet_naming_style.instance_field_style.capitalization = camel_case
dotnet_naming_style.instance_field_style.required_prefix = _
# Locals and parameters are camelCase
dotnet_naming_rule.locals_should_be_camel_case.severity = suggestion
dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
dotnet_naming_style.camel_case_style.capitalization = camel_case
# Local functions are PascalCase
dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style
dotnet_naming_symbols.local_functions.applicable_kinds = local_function
dotnet_naming_style.local_function_style.capitalization = pascal_case
# By default, name items with PascalCase
dotnet_naming_rule.members_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members
dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style
dotnet_naming_symbols.all_members.applicable_kinds = *
dotnet_naming_style.pascal_case_style.capitalization = pascal_case
# error RS2008: Enable analyzer release tracking for the analyzer project containing rule '{0}'
dotnet_diagnostic.RS2008.severity = none
# IDE0073: File header
#dotnet_diagnostic.IDE0073.severity = warning
#file_header_template = Licensed to the .NET Foundation under one or more agreements.\nThe .NET Foundation licenses this file to you under the MIT license.\nSee the LICENSE file in the project root for more information.
# IDE0035: Remove unreachable code
dotnet_diagnostic.IDE0035.severity = warning
# IDE0036: Order modifiers
dotnet_diagnostic.IDE0036.severity = warning
# IDE0043: Format string contains invalid placeholder
dotnet_diagnostic.IDE0043.severity = warning
# IDE0044: Make field readonly
dotnet_diagnostic.IDE0044.severity = warning
# CONSIDER: Are IDE0051 and IDE0052 too noisy to be warnings for IDE editing scenarios? Should they be made build-only warnings?
# IDE0051: Remove unused private member
dotnet_diagnostic.IDE0051.severity = warning
# IDE0170: Prefer extended property pattern
dotnet_diagnostic.IDE0170.severity = warning
# RS0016: Only enable if API files are present
dotnet_public_api_analyzer.require_api_files = true
# CSharp code style settings:

dotnet_diagnostic.IDE0044.severity = none # Make field readonly

# Make field readonly
dotnet_diagnostic.IDE0044.severity = none 
# Newline settings
csharp_new_line_before_open_brace = types
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_between_query_expression_clauses = true
# Indentation preferences
csharp_indent_block_contents = true
csharp_indent_braces = false
csharp_indent_case_contents = true
csharp_indent_case_contents_when_block = true
csharp_indent_switch_labels = true
csharp_indent_labels = flush_left
# Whitespace options
csharp_style_allow_embedded_statements_on_same_line_experimental = false
csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false
csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = false
# Prefer "var" everywhere
csharp_style_var_for_built_in_types = true:suggestion
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = true:suggestion
# Prefer method-like constructs to have a block body
csharp_style_expression_bodied_methods = false:none
csharp_style_expression_bodied_constructors = false:none
csharp_style_expression_bodied_operators = false:none
# Prefer property-like constructs to have an expression-body
csharp_style_expression_bodied_properties = true:none
csharp_style_expression_bodied_indexers = true:none
csharp_style_expression_bodied_accessors = true:none
# Suggest more modern language features when available
csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
csharp_style_inlined_variable_declaration = true:suggestion
csharp_style_throw_expression = true:suggestion
csharp_style_conditional_delegate_call = true:suggestion
csharp_style_prefer_extended_property_pattern = true:suggestion
# Space preferences
csharp_space_after_cast = false
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_after_comma = true
csharp_space_after_dot = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_after_semicolon_in_for_statement = true
csharp_space_around_binary_operators = before_and_after
csharp_space_around_declaration_statements = do_not_ignore
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_before_comma = false
csharp_space_before_dot = false
csharp_space_before_open_square_brackets = false
csharp_space_before_semicolon_in_for_statement = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_parentheses = false
csharp_space_between_square_brackets = false
# Blocks are allowed
csharp_prefer_braces = true:silent
csharp_preserve_single_line_blocks = true
csharp_preserve_single_line_statements = true
[src/{Analyzers,CodeStyle,Features,Workspaces,EditorFeatures,VisualStudio}/**/*.{cs,vb}]
# IDE0011: Add braces
csharp_prefer_braces = when_multiline:warning
# NOTE: We need the below severity entry for Add Braces due to https://github.com/dotnet/roslyn/issues/44201
dotnet_diagnostic.IDE0011.severity = warning
# IDE0040: Add accessibility modifiers
dotnet_diagnostic.IDE0040.severity = warning
# IDE0052: Remove unread private member
dotnet_diagnostic.IDE0052.severity = warning
# IDE0059: Unnecessary assignment to a value
dotnet_diagnostic.IDE0059.severity = warning
# IDE0060: Remove unused parameter
dotnet_diagnostic.IDE0060.severity = warning
# CA1012: Abstract types should not have public constructors
dotnet_diagnostic.CA1012.severity = warning
# CA1822: Make member static
dotnet_diagnostic.CA1822.severity = warning
# Prefer "var" everywhere
dotnet_diagnostic.IDE0007.severity = warning
csharp_style_var_for_built_in_types = true:warning
csharp_style_var_when_type_is_apparent = true:warning
csharp_style_var_elsewhere = true:warning
# dotnet_style_allow_multiple_blank_lines_experimental
dotnet_diagnostic.IDE2000.severity = warning
# csharp_style_allow_embedded_statements_on_same_line_experimental
dotnet_diagnostic.IDE2001.severity = warning
# csharp_style_allow_blank_lines_between_consecutive_braces_experimental
dotnet_diagnostic.IDE2002.severity = warning
# dotnet_style_allow_statement_immediately_after_block_experimental
dotnet_diagnostic.IDE2003.severity = warning
# csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental
dotnet_diagnostic.IDE2004.severity = warning
[src/{VisualStudio}/**/*.{cs,vb}]
# CA1822: Make member static
# There is a risk of accidentally breaking an internal API that partners rely on though IVT.
dotnet_code_quality.CA1822.api_surface = private