BITFALL/Assets/Artists/Scripts/Equip/BITGun.cs

using System;
using System.Linq;
using Animancer;
using BITFALL.Guns.Modify;
using BITFALL.Guns.States;
using BITFALL.Player.Equip;
using BITFALL.Player.Movement;
using UnityEngine;
using BITKit;
using BITKit.Animations;
using BITKit.Entities;
using BITKit.Entities.Melee;
using UnityEngine.InputSystem;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using Unity.Mathematics;
using UnityEngine.InputSystem.Interactions;
using Random = UnityEngine.Random;
#if UNITY_EDITOR
#endif

namespace BITFALL.Guns
{
    public interface IGunState : IState { }
    
    
    [System.Serializable]
    public abstract class GunState : IGunState
    {
        public BITGun root;
        [Inject]
        protected IEntityMovement _entityMovement;
        protected AnimancerComponent animancerComponent=>root.AnimancerComponent;
        public bool Enabled { get;set; }

        protected string[] AnimationKey;
        protected bool PlayAnimation(params string[] args)
        {
            if (root.MotionMatchingService.TryMatch(out var obj,args) is false) return false;
            switch (obj)
            {
                case IMotionMatchingClip clip:
                    animancerComponent.Play(clip.Clip,0.1f);
                    return true;
                case IMotionMatchingSequence sequence:
                    //animancerComponent.Play(sequence.Sequence);
                    return true;
            }
            return false;
        }

        protected void PlayAnimation(Action OnEnd = null)
        {
            if (root.MotionMatchingService.TryMatch(out var obj,AnimationKey) is false) return;
            switch (obj)
            {
                case IMotionMatchingClip clip:
                   var state = animancerComponent.Play(clip.Clip, 0.1f);
                   state.Events.OnEnd=OnEnd is null ? null : () =>
                   {
                       state.Events.OnEnd = null;
                       this.OnEnd();
                   };
                    break;
            }
        }
        public virtual void Initialize()
        {
            root.Entity.Inject(this);
            _entityMovement.OnStateChanged += OnMovementStateChanged;
           // AnimationKey = new []{BITGun.C_Weapon,GetType().Name,root._gun.Name};
            AnimationKey = root.SearchKey.Append(GetType().Name).ToArray();
        }

        public virtual void OnStateEntry(IState old)
        {
            PlayAnimation(OnEnd);
        }

        public virtual void OnStateExit(IState old, IState newState)
        {
        }

        public virtual void OnStateUpdate(float deltaTime)
        {
        }
        public virtual void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
        }
        public virtual void AnimationEvent(string name)
        {
        }

        protected virtual void OnEnd()
        {
            
        }
    }
    [System.Serializable]
    public class GunStateMachine : MonoStateMachine<GunState> { }
    public class BITGun : BITEquipBase<GunState>
    {
        [RuntimeInitializeOnLoadMethod]
        private static void Reload()
        {
            _token =(uint)(uint.MaxValue * Random.value);
        }
        public static uint Token => _token += 1;

        private static uint _token;
        //简单设置
        [Header(Constant.Header.Settings)]
        [SerializeField] private Vector3 bulletInitialOffset;
        [SerializeField] private SpringEulerAngle recoilSpring=new();
        [SerializeField] private float recoilPositionWeight=1;

        [Header(Constant.Header.Gameobjects)]
        [SerializeField] private Transform initialSight;
        [SerializeField] private Optional<Transform> newSight;
        
        [Header(nameof(Optional<GameObject>))]
        [SerializeField] private Optional<LocationAdditive> breathingAdditive;
        
        //  输入系统
        [Header(Constant.Header.Input)]
        [SerializeField] internal InputActionReference fireAction;
        [SerializeField] internal InputActionReference aimAction;
        [SerializeField] internal InputActionReference reloadAction;
        [SerializeField] internal InputActionReference meleeAction;
        [SerializeField] internal InputActionReference steadyAimAction;
        [SerializeField] internal InputActionReference inspectAction;

        [Header(Constant.Header.HotFix)]
        [SerializeField] private Transform cameraView;
        //  引用组件
        [Header(Constant.Header.Components)]
        [SerializeField] private LocationAdditive locationAdditive;
        [SerializeField] private LocationAdditive selfViewAdditive;
        
        //  引用预制体
        [Header(Constant.Header.Prefabs)]
        // 内部变量burst
        [Header(Constant.Header.InternalVariables)]
        public ExpectState<bool> expectFiring;
        public ExpectState<bool> expectAiming;
        internal readonly IntervalUpdate fireInterval = new(0.32f);
        internal readonly IntervalUpdate burstFireInterval = new(0.1f);
        internal int burstFireCount;
        [Inject]
        private IEntityMovement _movement;
        [Inject]
        private IPlayerMovement _playerMovement;
        [Inject]
        private IHealth _health;

        [Inject] private IEquipService _equipService;
     
        internal AssetableGun _gun=>item as AssetableGun;
        private bool isSteadyAim;

        private readonly DoubleBuffer<int> cacheRounds = new();
        
        private readonly Optional<Vector3>  _fixAimPosition = new();
        
        public bool RequireBolt { get; set; }
        
        #region 接口实现
        public override string AddressablePath => _gun.AddressablePath;
        #endregion

        private LinearMixerState walkState;
        private AnimancerState jumpState;

        public override void OnAwake()
        {
            base.OnAwake();

            AnimancerComponent.Layers[3].IsAdditive = true;
            AnimancerComponent.Layers[2].IsAdditive = true;
            AnimancerComponent.Layers[4].IsAdditive = true;
            
            if (breathingAdditive.Allow)
                inputActionGroup.RegisterCallback(steadyAimAction, OnSteadyAim);
            

            BITAppForUnity.AllowCursor.AddListener(OnAllowCursor);
            destroyCancellationToken.Register(() => { BITAppForUnity.AllowCursor.RemoveListener(OnAllowCursor); });
        }

        private void OnAllowCursor(bool allow)
        {
            if (!allow) return;
            expectFiring.Reset();
            expectAiming.Reset();
        }

        private void OnSteadyAim(InputAction.CallbackContext obj)
        {
            switch (obj)
            {
                case { interaction: PressInteraction, performed: true } when CurrentState is Aim:
                    isSteadyAim = true;
                    break;
                case { interaction: PressInteraction, canceled: true }:
                    isSteadyAim = false;
                    break;
            }
        }

        private void OnMovementCommand(object obj)
        {
            switch (obj)
            {
                case OnPlayerJumpCommand when
                    MotionMatchingService.TryMatch(out var jump ,SearchKey.Append("Jump").ToArray())
                    && jump is IMotionMatchingClip jumpMotion
                    :
                    jumpState?.Stop();
                    jumpState = AnimancerComponent.Layers[4].Play(jumpMotion.Clip);
                    break;
                case OnPlayerLandCommand when
                    MotionMatchingService.TryMatch(out var land ,SearchKey.Append("Land").ToArray())
                    && land is IMotionMatchingClip landMotion
                    :
                    jumpState?.Stop();
                    jumpState = AnimancerComponent.Layers[4].Play(landMotion.Clip,0.1f);
                    jumpState.Events.OnEnd = () =>
                    {
                        jumpState.Events.OnEnd = null;
                         jumpState.StartFade(0);
                    };
                    break;
            }
        }

        private void OnMelee(InputAction.CallbackContext obj)
        {
            switch (CurrentState)
            {
                case Equip:
                case Melee:
                    return;
            }
            TransitionState<Melee>();
        }

        private void OnReload(InputAction.CallbackContext obj)
        {
            if (obj.JustPressed() is false) return;
            switch (CurrentState)
            {
                case Equip:
                case Melee:
                    return;
            }

            if (Item?.TryGetProperty<IClip>(out var clip) is false)
            {
                _uxPopup?.Popup("<color=yellow>机匣损坏或不存在</color>");
                return;
            }
            if (_inventory.TryGetItem(IsClipReady, out var clipItem) is false)
            {
                _uxPopup?.Popup("<color=yellow>没有兼容的弹夹</color>");
                return;
            }
            TransitionState<Reload>();
        }

        public override void Entry()
        {
            base.Entry();
            _movement.ExecuteCommand(new PlayerLimitMoveSpeedCommand()
            {
                Id = BITHash.Player.Equip,
                Limit = true,
                Speed = _gun.InitialMovementSpeed
            });
            
            inputActionGroup.RegisterCallback(fireAction, OnFire);
            inputActionGroup.RegisterCallback(aimAction, OnAim);
            inputActionGroup.RegisterCallback(reloadAction, OnReload);
            inputActionGroup.RegisterCallback(meleeAction, OnMelee);
            
            TransitionState<Equip>();

            if (MotionMatchingService.TryMatch(out var walkMotion, SearchKey.Append(BITConstant.Player.Walk).ToArray())
                &&
                MotionMatchingService.TryMatch(out var movementMotion, SearchKey.Append(BITConstant.Player.Movement).ToArray()))
            {
                if (walkMotion is IMotionMatchingClip walkClip && movementMotion is IMotionMatchingClip movementClip)
                {
                    walkState = new LinearMixerState
                    {
                        { movementClip.Clip, 0 },
                        { walkClip.Clip, 1 }
                    };
                    AnimancerComponent.Layers[2].Play(walkState);
                    //walkState = AnimancerComponent.Layers[2].Play(walkClip.Clip);
                }
            }
            
            _movement.OnStateChanged += OnMovementStateChanged;
            _movement.OnCommand += OnMovementCommand;
        }

        private bool IsClipReady(IBasicItem clip)
        {
            if(Item.TryGetProperty<IClip>(out var _clip) is false) return false;
            if(clip.AddressablePath != _clip.AddressablePath) return false;
            if(clip.TryGetProperty<IClip>(out var _clipItem) is false) return false;
            return _clipItem.Remaining > 0;
        }
        private void OnMovementStateChanged(IEntityMovementState arg1, IEntityMovementState arg2)
        {
            if (IsEntered is false) return;
            foreach (var x in StateDictionary.Values)
            {
                x.OnMovementStateChanged(arg1,arg2);
            }
        }

        public override void Exit()
        {
            base.Exit();
            if (Item.TryGetProperty<IClip>(out var clip) && cacheRounds.TryGetRelease(out var rounds))
            {
                clip.Remaining = rounds;
            }
            cacheRounds.Clear();
            
            inputActionGroup.UnRegisterCallback(fireAction, OnFire);
            inputActionGroup.UnRegisterCallback(aimAction, OnAim);
            inputActionGroup.UnRegisterCallback(reloadAction, OnReload);
            inputActionGroup.UnRegisterCallback(meleeAction, OnMelee);
            
            _movement.OnStateChanged -= OnMovementStateChanged;
            _movement.OnCommand -= OnMovementCommand;
        }

        public override UniTask EntryAsync()
        {
            base.EntryAsync();
            
            expectFiring.Reset();
            Enabled = true;

            fireInterval.Interval = 1f / _gun.FireMode.FireRate;
            fireInterval.Reset();

            if (_gun.FireMode is BurstFireMode burstFireMode)
            {
                burstFireInterval.Interval = burstFireMode.BurstFireInterval;
                burstFireInterval.Reset();
            }

            TransitionState<Equip>();
            
            return UniTask.CompletedTask;
        }

        public override async UniTask ExitAsync()
        {
            TransitionState<Holster>();
            
            _movement.ExecuteCommand(new PlayerFocusCommand()
            {
                Focus = false,
                Sender = this
            });
            
            _equipService.AllowAttack = false;
            
            //inputActionGroup.allowInput.RemoveElement(this);
            expectFiring.Reset();

            cameraView.localPosition = default;

            try
            {
                while (_health.IsAlive && AnimancerComponent.IsPlaying())
                {
                    destroyCancellationToken.ThrowIfCancellationRequested();
                    _equipService.Zoom.Value = Mathf.MoveTowards(_equipService.Zoom.Value,0,Time.deltaTime);
                    await UniTask.NextFrame();
                }

                _equipService.Zoom.Allow = false;

                destroyCancellationToken.ThrowIfCancellationRequested();

                _equipService.Stable = 1;
              

                await base.ExitAsync();
            }
            catch (OperationCanceledException)
            {
            }
        }

        public override void Exited()
        {
            base.Exited();
            _movement.ExecuteCommand(new PlayerLimitMoveSpeedCommand()
            {
                Id = BITHash.Player.Equip,
                Limit = false,
                Speed = _gun.InitialMovementSpeed
            });
        }

        public override void OnUpdate(float deltaTime)
        {
            base.OnUpdate(deltaTime);
            UpdateState(deltaTime);
            switch (_gun.FireMode)
            {
                case AutoFireMode:
                    break;
                case SemiFireMode:
                    break;
                case BurstFireMode when expectFiring.being:
                    expectFiring.shouldBe = fireAction.action.WasPressedThisFrame();
                    if(burstFireInterval.AllowUpdate)
                    {
                        switch (AnimationProperties.TryGetValue(BITConstant.Player.AllowFire, out var allowFire))
                        {
                            case false:
                            case true when allowFire >0.9f:
                                Fire();
                                break;
                        }
                    }
                    break;
            }

            _movement.ExecuteCommand(new PlayerFocusCommand()
            {
                Focus = recoilSpring.value.GetLength() > 0.1f,
                Sender = this
            });
            
            if(AnimationProperties.TryGetValue(BITConstant.Player.Aim, out var __aim))
            {
                //animator.animator.SetFloat((int)BITHash.Player.Aim,__aim);
            }
         
            var length = _movement.GroundVelocity.GetLength();
           // animator.animator.SetFloat(BITConstant.Player.SqrMagnitude,
           //     Mathf.Clamp(
           //         length / _movement.ReferenceSpeed,0.1f,1
           //         )
           //     );

           if (walkState is not null)
           {
               var value = Mathf.Clamp(
                       length / _movement.ReferenceSpeed, 0, 1
                   );
               walkState.Parameter = value;

           }
            
            recoilSpring.Update(deltaTime,default);

            if (_gun.TryGetProperty<IRecoil>(out var recoil) && locationAdditive)
            {
                //locationAdditive.AddEuler(Vector3.Scale(recoilSpring.value,recoil.ViewRecoilScale) );
                locationAdditive.AddRotation(Quaternion.Euler(Vector3.Scale(recoilSpring.value,recoil.ViewRecoilScale)));
            }
          
            if (selfViewAdditive)
            {
                var positionWeight = recoilPositionWeight;
                if (AnimationProperties.TryGetValue(BITConstant.Player.Aim, out var aim))
                {
                    positionWeight *= Mathf.Lerp(2, 1, aim);
                }
                //selfViewAdditive.AddEuler(recoilSpring.value);
                selfViewAdditive.AddRotation(Quaternion.Euler(recoilSpring.value));
                selfViewAdditive.AddPosition(
                    new Vector3(
                        recoilSpring.value.y,
                        -recoilSpring.value.x,
                        recoilSpring.value.z
                    ) *
                    positionWeight
                );
            }

            if(AnimationProperties.TryGetValue(BITConstant.Player.Aim, out var _aim))
            {
                _equipService.Zoom.Allow = CurrentState is Aim;
                _equipService.Zoom.Value =Mathf.Lerp(1,_gun.InitialAimZoom, _aim);
                _equipService.AllowScope = _aim > 0.5f && _gun.IsScopeAim;
                _equipService.Aim = _aim;
                

                if (breathingAdditive.Allow)
                {
                    var breatheFrequency = 0.5f; // 呼吸的频率，值越大呼吸越快
                    var breatheAmplitude = 0.005f; // 呼吸的幅度，即准星上下移动的最大距离

                    if (_playerMovement.Stamina <= 8)
                    {
                        breatheFrequency = 8;
                        breatheAmplitude = 0.1f;
                    }
                    
                    var breatheOffset = Mathf.Sin(Time.time * breatheFrequency) * breatheAmplitude;

                    if (isSteadyAim)
                    {
                        if (_playerMovement.Stamina > 0)
                        {
                            _playerMovement.Stamina -= 16 * deltaTime;
                            breatheOffset *= 0.16f;
                        }
                        else
                        {
                            isSteadyAim = false;
                        }
                    }
                    else
                    {
                        breatheOffset *= _aim;
                    }
                    
                    _playerMovement.AddViewEuler(new float2(breatheOffset, breatheOffset));
                }

                if (newSight.Allow)
                {
                    transform.localPosition = Vector3.Lerp(default, _fixAimPosition.Value, _aim);
                    
                    
                }
                else
                {
                    transform.localPosition = default;
                }
            }

            if (AnimationProperties.TryGetValue(BITConstant.Player.Stable, out var stable))
            {
                _equipService.Stable = stable;
            }
            
            if(AnimationProperties.TryGetValue(BITConstant.Player.AllowFire, out var _allowFire))
            {
                _equipService.AllowAttack = _allowFire > 0.9f;
            }
            
            //AllowRendering.SetDisableElements(64564,_equipService.AllowScope);

            expectAiming.shouldBe = inputActionGroup.GetAction(aimAction).IsPressed();
        }

        public override void AnimationEvent(string eventName)
        {
            if (IsEntered is false) return;
            base.AnimationEvent(eventName);
            CurrentState?.AnimationEvent(eventName);
            
            
            
            if (Item.TryGetProperty<IClip>(out var clip) 
                && _inventory.TryGetItem(IsClipReady, out var clipItem)
                && clipItem.TryGetProperty<IClip>(out var nextClip)
                )
                switch (eventName)
                {
                    case BITConstant.Player.EjectClip:
                        if(clip.Remaining <= 0) break;
                        cacheRounds.Release(clip.Remaining);
                        clip.Remaining = 0;
                        break;
                    case BITConstant.Player.InsertClip:
                        cacheRounds.TryGetRelease(out var current);

                        var newRound = nextClip.Remaining;
                        var swapClipClone = nextClip.Clone().As<IClip>();
                        
                        var swapClip = clipItem.Clone().As<IBasicItem>();
                        swapClipClone.Remaining = current;
                        if (swapClip.TrySetProperty(swapClipClone) is false || _inventory.TrySetItem(swapClip) is false)
                        {
                            _uxPopup?.Popup("<color=yellow>弹匣回收失败</color>");
                            clip.Remaining = current;
                            break;
                        }
                        else
                        {
                            clip.Remaining = newRound;
                        }
                        // var newRound = Mathf.Clamp(current + nextClip.Remaining, 0,int.MaxValue);
                        //
                        // newRound = nextClip.Remaining;
                        //
                        // var newClipItem = clipItem.Clone() as IBasicItem;
                        // nextClip = nextClip.Clone().As<IClip>();
                        //
                        // if(newRound>clip.Capacity)
                        // {
                        //     newRound = clip.Capacity;
                        //     nextClip.Remaining = current + nextClip.Remaining - clip.Capacity;
                        // }
                        // else
                        // {
                        //     nextClip.Remaining = 0;
                        // }
                        // if(newRound == 0)
                        // {
                        //     _uxPopup?.Popup("<color=yellow>空弹匣</color>");
                        //     break;
                        // }
                        //
                        // newClipItem!.TrySetProperty(nextClip);
                        //
                        // if (_inventory.TrySetItem(newClipItem))
                        // {
                        //     clip.Remaining = newRound;
                        // }
                        // else
                        // {
                        //     clip.Remaining = current;
                        //     _uxPopup?.Popup("<color=yellow>弹匣回收失败</color>");
                        // }
                        break;
                }
        }

        public void Fire()
        {
            if (RequireBolt) return;
            var infiniteAmmo = Data.Get<int>(BITConstant.Environment.sv_infinite_ammo) is 1;
            switch (Item.TryGetProperty<IClip>(out var clip))
            {
                case false:
                case true when infiniteAmmo:
                    break;
                case true when clip.Remaining >0:
                    clip.Remaining--;
                    break;
                default:
                    return;
            }
            
            //播放射击动画
            //UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.Fire);

            if (MotionMatchingService.TryMatch(out var motion, SearchKey.Append(
                    CurrentState is Aim ? BITConstant.Player.AimFire : BITConstant.Player.Fire
                ).ToArray()))
            {
                if (motion is IMotionMatchingClip fireClip)
                {
                    AnimancerComponent.Layers[3].Stop();
                    var state =AnimancerComponent.Layers[3].Play(fireClip.Clip);
                    state.Events.OnEnd = () =>
                    {
                        state.Events.OnEnd = null;
                    };
                }
            }


            if (_gun.BuckShot.Allow)
            {
                InternalAddRecoil();
                InternalFire(_gun.BuckShot.Value);    
                // for (int i = 0; i < _gun.BuckShot.Value; i++)
                // {
                //    
                // }
            }
            else
            {
                InternalFire();    
                InternalAddRecoil();
            }
           

            //开火模式逻辑判断
            switch (_gun.FireMode)
            {
                case AutoFireMode:
                    break;
                case SemiFireMode:
                    //如果是半自动开火,则取消射击
                    expectFiring.Reset();
                    break;
                case BurstFireMode burstFireMode:
                    burstFireCount++;
                    expectFiring.being = true;
                    if(burstFireCount > burstFireMode.BurstRound)
                    {
                        burstFireCount = 0;
                        expectFiring.Reset();
                    }
                    break;
            }

            if (_gun.FireMode is SemiFireMode {RequireBoltAction:true})
            {
                RequireBolt = true;
            }
        }

        private void InternalFire(int count = 1)
        {
            //调用BulletManager生成子弹
            var _transform = transform;
            var rotation =_movement.ViewRotation;
            var position = _movement.Position;
            position.y = _transform.position.y;
            var fireRecoil = Vector2.one;
            if (_gun.TryGetProperty<ISpread>(out var spread))
            {
                fireRecoil *= spread.Spread;
            }
            if(AnimationProperties.TryGetValue(BITConstant.Player.Aim, out var aim))
            {
                fireRecoil *= Mathf.Lerp(_gun.InitialHipFireSpread,1,aim);
            }
            fireRecoil *= recoilSpring.value.GetLength();
            var length = fireRecoil.GetLength();
            for (var i = 0; i < count; i++)
            {
                float angle = i * 2 * Mathf.PI / count;
                float x = length * Mathf.Cos(angle);
                float y = length * Mathf.Sin(angle);

                Vector2 point = new Vector2(x, y);
                BulletService.Spawn(new SpawnBullet
                {
                    Token = Token,
                    Initiator = Entity.Id,
                    //Position = (_transform.position+rotation * bulletInitialOffset),
                    //Rotation = rotation,
                    Position = position,
                    Rotation = rotation,
                    Forward = rotation * (Vector3.forward + Vector3.up * point.y + Vector3.right * point.x),
                    InitialDamage = _gun.InitialDamage,
                    StartSpeed = _gun.InitialBulletSpeed,
                    InitialForce = _gun.InitialBulletForce,
                });
            }
        }

        private void InternalAddRecoil()
        {
            if (_gun.TryGetProperty<IRecoil>(out var _recoil))
            {
                var _newRecoil =  new Vector3
                {
                    x = _recoil.Recoil.x,
                    y = _recoil.Recoil.y.Random(),
                    z = _recoil.Recoil.z.Random()
                };
                recoilSpring.value = _newRecoil;
                _playerMovement.AddViewEuler(new float2(_newRecoil.x,_newRecoil.y));
            }
        }
        private void OnFire(InputAction.CallbackContext context)
        {
            //如果启用了指针则不开火
            if(BITAppForUnity.AllowCursor)
            {
                expectFiring.Reset();
                return;
            }
            switch (_gun.FireMode)
            {
                case AutoFireMode :
                    switch (context)
                    {
                        case {interaction:PressInteraction , started:true}:
                            expectFiring.shouldBe = true;
                            break;
                        case {interaction:PressInteraction , canceled:true}:
                            expectFiring.shouldBe = false;
                            break;
                    }
                    break;
                case SemiFireMode:
                    switch (context)
                    {
                        case { interaction: PressInteraction, started: true } when fireInterval.AllowUpdateWithoutReset && RequireBolt is false:
                            expectFiring.shouldBe = true;
                            break;
                    }
                    break;
            }
        }
        private void OnAim(InputAction.CallbackContext context)
        {
            //如果启用了指针则不开火
            if(BITAppForUnity.AllowCursor)
            {
                expectAiming.Reset();
                return;
            }
            //expectAiming.shouldBe = context.ReadValueAsButton();
        }

        protected override void OnItemApplied(IBasicItem item)
        {
            base.OnItemApplied(item);
            // var aim = GetComponentInChildren<GunControllerAimComponent>();
            // newSight.Allow = aim;
            // if (aim)
            // {
            //     newSight.Value = aim.transform;     
            //     var initialSightPos = Transform.InverseTransformVector(initialSight.position);
            //     var newSightPos = Transform.InverseTransformVector(newSight.Value.position);
            //     _fixAimPosition.SetValueThenAllow( (newSightPos.y -initialSightPos.y) * Vector3.up);
            // }
            // else
            // {
            //     _fixAimPosition.Clear();
            // }
        }
    }
    // #if UNITY_EDITOR
    // [CustomEditor(typeof(BITGun))]
    // public class BITGunInspector:BITInspector<BITGun>{}
    // #endif
}