OldBlueWater/BlueWater/Assets/02.Scripts/Player/Cannon.cs

using System;
using System.Collections;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.InputSystem;
using Random = UnityEngine.Random;

// ReSharper disable once CheckNamespace
namespace BlueWaterProject
{
    public class Cannon : MonoBehaviour
    {
        /***********************************************************************
         *                               Definitions
         ***********************************************************************/
        #region Definitions

        private enum LaunchType
        {
            NONE = -1,
            FIXED_ANGLE,
            FIXED_SPEED
        }

        #endregion
        
        /***********************************************************************
         *                               Variables
         ***********************************************************************/
        #region Variables

        // 컴포넌트
        [TitleGroup("컴포넌트"), BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private PlayerInput playerInput;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private GameObject projectileObject;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private Transform visualLook;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private Transform launchTransform;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private LineRenderer predictedLine;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [SerializeField] private GameObject hitMarker;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [SerializeField] private GameObject directionIndicator;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [SerializeField] private ProcessBar launchProcessBar;
        
        [BoxGroup("컴포넌트/컴포넌트", ShowLabel = false)]
        [Required, SerializeField] private Transform instantiateObjects;
        
        // 대포 기본 설정
        [TitleGroup("대포 기본 설정")]
        
        // 게이지
        [BoxGroup("대포 기본 설정/게이지")]
        [Range(0.1f, 5f), Tooltip("게이지가 모두 차는데 걸리는 시간\n게이지는 0 ~ 1의 값을 가짐")]
        [SerializeField] private float gaugeChargingTime = 1f;

        // 발사 기능
        [BoxGroup("대포 기본 설정/발사 기능")]
        [Range(0f, 3f), Tooltip("발사 재사용 시간")]
        [SerializeField] private float launchCooldown = 1f;
        
        [BoxGroup("대포 기본 설정/발사 기능")]
        [Range(1f, 100f), Tooltip("발사될 거리 계수\nchargingGauge * 변수값")]
        [SerializeField] private float distanceCoefficient = 40f;
        
        [BoxGroup("대포 기본 설정/발사 기능")]
        [Tooltip("발사 방식")]
        [SerializeField] private LaunchType launchType = LaunchType.FIXED_ANGLE;
        
        [BoxGroup("대포 기본 설정/발사 기능")]
        [ShowIf("@launchType == LaunchType.FIXED_SPEED"), Range(0f, 100f), Tooltip("발사 속도")]
        [SerializeField] private float launchSpeed = 20f;
        
        [BoxGroup("대포 기본 설정/발사 기능")]
        [ShowIf("@launchType == LaunchType.FIXED_ANGLE"), Range(0f, 60f), Tooltip("발사 각도")]
        [SerializeField] private float launchAngle = 10f;

        // 예측 기능
        [BoxGroup("대포 기본 설정/예측 기능")]
        [SerializeField] private bool isUsingPredictLine;
        
        [BoxGroup("대포 기본 설정/예측 기능")]
        [ShowIf("@isUsingPredictLine"), Range(1, 300), Tooltip("발사 예측선 갯수")]
        [SerializeField] private int lineMaxPoint = 200;
        
        [BoxGroup("대포 기본 설정/예측 기능")]
        [ShowIf("@isUsingPredictLine"), Range(0.001f, 1f), Tooltip("발사 예측선 간격")]
        [SerializeField] private float lineInterval = 0.025f;
        
        // 기타
        [BoxGroup("대포 기본 설정/기타")]
        [Tooltip("랜덤으로 잡힐 물고기 마릿수 x, y를 포함하는 사이의 값")]
        [SerializeField] private Vector2 randomCatch = new(1, 4);
        
        [BoxGroup("대포 기본 설정/기타")]
        [SerializeField] private float mouseRayDistance = 500f;
        
        [BoxGroup("대포 기본 설정/기타")]
        [SerializeField] private float rayDistance = 100f;
        
        [BoxGroup("대포 기본 설정/기타")]
        [SerializeField] private LayerMask hitLayer;
        
        [BoxGroup("대포 기본 설정/기타")]
        [SerializeField] private LayerMask waterLayer;
        
        [BoxGroup("대포 기본 설정/기타")]
        [SerializeField] private LayerMask boidsLayer;
        
        // 카메라 효과 옵션
        [TitleGroup("카메라"), BoxGroup("카메라/카메라 흔들림 효과", ShowLabel = false)]
        [SerializeField] private float cameraShakePower = 2f;
        
        [BoxGroup("카메라/카메라 흔들림 효과", ShowLabel = false)]
        [SerializeField] private float cameraShakeDuration = 0.3f;
        
        // 실시간 상태
        [TitleGroup("실시간 상태")]
        [DisableIf("@true")]
        [SerializeField] private bool isLaunchMode;
        [DisableIf("@true")]
        [SerializeField] private bool isCharging;
        [DisableIf("@true")]
        [SerializeField] private bool isReloading;
        [DisableIf("@true")]
        [SerializeField] private float chargingGauge;
        [DisableIf("@true")]
        [SerializeField] private float previousGauge;

        private float cannonRadius;
        private Vector3 launchVelocity;
        private Collider[] hitColliders;
        private GameObject newHitMarker;
        private RaycastHit endPositionHit;

        private const int MAX_HIT_SIZE = 8;
        
        #endregion
        
        /***********************************************************************
         *                               Unity Events
         ***********************************************************************/
        #region Unity Events

        private void Start()
        {
            cannonRadius = projectileObject.GetComponent<SphereCollider>()?.radius ??
                           projectileObject.GetComponent<ParticleWeapon>().colliderRadius;
            
            launchProcessBar = UiManager.Inst.OceanUi.ProcessBar;
            hitColliders = new Collider[MAX_HIT_SIZE];
        }

        private void OnEnable()
        {
            playerInput.actions.FindAction("ToggleCannon").started += _ => ToggleCannon();
            playerInput.actions.FindAction("FireCannon").started += _ => ChargeCannon();
            playerInput.actions.FindAction("FireCannon").canceled += _ => FireCannon();
        }
        
        private void OnDisable()
        {
            playerInput.actions.FindAction("ToggleCannon").started -= _ => ToggleCannon();
            playerInput.actions.FindAction("FireCannon").started -= _ => ChargeCannon();
            playerInput.actions.FindAction("FireCannon").canceled -= _ => FireCannon();
        }

        private void Update()
        {
            HandleFireCannon();
        }

        #endregion

        /***********************************************************************
         *                               Init Methods
         ***********************************************************************/
        #region Init Methods

        [Button("셋팅 초기화")]
        private void Init()
        {
            playerInput = GetComponentInParent<PlayerInput>();
            projectileObject = Utils.LoadFromFolder<GameObject>("Assets/05.Prefabs/Particles/GrenadeFire", "GrenadeFireOBJ", ".prefab");
            visualLook = transform.Find("VisualLook");
            launchTransform = transform.Find("LaunchPosition");
            predictedLine = transform.Find("CannonLineRenderer").GetComponent<LineRenderer>();
            if (predictedLine)
            {
                predictedLine.gameObject.SetActive(false);
            }
            hitMarker = Utils.LoadFromFolder<GameObject>("Assets/05.Prefabs", "HitMarker", ".prefab");
            // directionIndicator = transform.parent.Find("DirectionIndicator")?.gameObject;
            // if (directionIndicator)
            // {
            //     directionIndicator.SetActive(false);
            // }
            instantiateObjects = GameObject.Find("InstantiateObjects").transform;
            
            waterLayer = LayerMask.GetMask("Water");
            boidsLayer = LayerMask.GetMask("Boids");
        }

        #endregion
        
        /***********************************************************************
         *                              PlayerInput
         ***********************************************************************/
        #region PlayerInput
        
        private void ToggleCannon()
        {
            isLaunchMode = !isLaunchMode;
            if (directionIndicator)
            {
                directionIndicator.SetActive(isLaunchMode);
            }
            launchProcessBar.SetActive(isLaunchMode);

            if (!isLaunchMode)
            {
                isCharging = false;
                predictedLine.gameObject.SetActive(false);
                if (newHitMarker)
                {
                    Destroy(newHitMarker);
                }
                chargingGauge = 0f;
                previousGauge = chargingGauge;
                launchProcessBar.SetFillAmount(0f);
                launchProcessBar.SetRotateZ(previousGauge * -360f);
                launchProcessBar.SetRotateZ(0f);
                launchProcessBar.SetSliderValue(0f);
            }
        }

        private void ChargeCannon()
        {
            if (!isLaunchMode) return;

            if (isReloading)
            {
                StartCoroutine(UiManager.Inst.OceanUi.ProcessBar.ShakeProcessBarCoroutine());
            }
            else
            {
                predictedLine.gameObject.SetActive(true);
                if (hitMarker)
                {
                    newHitMarker = Instantiate(hitMarker, Vector3.zero, hitMarker.transform.rotation, instantiateObjects);
                    newHitMarker.transform.localScale *= cannonRadius * 2f;
                    hitMarker.SetActive(true);
                }
                isCharging = true;
                chargingGauge = 0f;
            }
        }

        private void FireCannon()
        {
            if (!isLaunchMode || !isCharging) return;
            
            isCharging = false;
            predictedLine.gameObject.SetActive(false);
            previousGauge = chargingGauge;
            chargingGauge = 0f;
            launchProcessBar.SetFillAmount(0f);
            launchProcessBar.SetRotateZ(previousGauge * -360f);
            Launch();
            
            StartCoroutine(LaunchCoolDown(launchCooldown));
        }

        #endregion
        
        /***********************************************************************
         *                              Methods
         ***********************************************************************/
        #region Methods
        
        private void HandleFireCannon()
        {
            if (!isLaunchMode) return;

            var ray = CameraManager.Inst.MainCam.ScreenPointToRay(Input.mousePosition);

            if (Physics.Raycast(ray, out var hit, mouseRayDistance, waterLayer, QueryTriggerInteraction.Collide))
            {
                var directionToMouse = (hit.point - transform.position).normalized;
                directionToMouse.y = 0f;

                var lookRotation = Quaternion.LookRotation(directionToMouse);
                var cannonRotationDirection = Quaternion.Euler(0f, lookRotation.eulerAngles.y, 0f);
                if (directionIndicator)
                {
                    directionIndicator.transform.rotation = cannonRotationDirection;
                }
                
                transform.rotation = cannonRotationDirection;
            }
            
            if (!isCharging) return;

            if (chargingGauge < 1f)
            {
                if (gaugeChargingTime == 0f)
                {
                    gaugeChargingTime = 1f;
                }
                
                chargingGauge += 1 / gaugeChargingTime * Time.deltaTime;
                chargingGauge = Mathf.Clamp(chargingGauge, 0f, 1f);
            }
            else
            {
                chargingGauge = 1f;
            }
            launchProcessBar.SetFillAmount(chargingGauge);
            
            CalculateLaunchTrajectory();
        }
        
        private void CalculateLaunchTrajectory()
        {
            var startPosition = launchTransform.position;
            var endPosition = CalculateEndPosition();
            var d = Vector3.Distance(new Vector3(endPosition.x, 0, endPosition.z), new Vector3(startPosition.x, 0, startPosition.z));
            var h = endPosition.y - startPosition.y;
            
            switch (launchType)
            {
                case LaunchType.NONE:
                    break;
                case LaunchType.FIXED_ANGLE:
                    var currentEulerX = Utils.NormalizeEulerAngle(visualLook.eulerAngles.x);
                    launchTransform.localRotation = Quaternion.Euler(currentEulerX + launchAngle, 0, 0);
                    
                    var theta = launchAngle * Mathf.Deg2Rad;
                    var g = Physics.gravity.magnitude;
                    var v0 = Mathf.Sqrt((g * d * d) / (2 * Mathf.Cos(theta) * Mathf.Cos(theta) * (d * Mathf.Tan(theta) - h)));
        
                    launchVelocity = CalculateVelocityFromAngleAndSpeed(startPosition, theta, v0);
                    break;
                case LaunchType.FIXED_SPEED:
                    var targetDirection = (endPosition - startPosition).normalized;
                    targetDirection.y = 0;
                    var angle = CalculateAngleForFixedSpeed(d, h, launchSpeed);
                    
                    var launchDirection = Quaternion.LookRotation(targetDirection) * Quaternion.Euler(-angle, 0, 0);
                    launchTransform.rotation = launchDirection;
                    launchVelocity = launchTransform.forward * launchSpeed;
                    
                    // var angle = CalculateAngleForFixedSpeed(d, h, launchSpeed);
                    //
                    // launchTransform.localRotation = Quaternion.Euler(-angle, 0, 0);
                    // launchVelocity = launchTransform.forward * launchSpeed;
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            PredictLine(startPosition);
        }

        private float CalculateAngleForFixedSpeed(float x, float y, float speed)
        {
            var g = Physics.gravity.magnitude;
            var speedSq = speed * speed;
            var underRoot = speedSq * speedSq - g * (g * x * x + 2 * y * speedSq);

            if (underRoot < 0)
            {
                Debug.LogError("Unreachable target with given speed.");
                return 0;
            }

            var root = Mathf.Sqrt(underRoot);
            var angle1 = Mathf.Atan((speedSq + root) / (g * x));
            var angle2 = Mathf.Atan((speedSq - root) / (g * x));
            
            var selectedAngle = Mathf.Min(angle1, angle2) * Mathf.Rad2Deg;
            return selectedAngle;
        }
        
        private Vector3 CalculateEndPosition()
        {
            var direction = transform.forward;
            direction.y = 0f;
            var startPosition = launchTransform.position + direction.normalized * (chargingGauge * distanceCoefficient);
            Debug.DrawRay(startPosition, Vector3.down * rayDistance, Color.blue, 3f);
            
            if (Physics.Raycast(startPosition, Vector3.down, out endPositionHit, rayDistance, hitLayer, QueryTriggerInteraction.Collide))
            {
                Debug.DrawRay(endPositionHit.point, Vector3.down * rayDistance, Color.red, 3f);
                return endPositionHit.point;
            }
            print("?");
            return startPosition;
        }

        private Vector3 CalculateVelocityFromAngleAndSpeed(Vector3 startPosition, float angleRad, float speed)
        {
            var direction = launchTransform.forward;
            direction.y = 0;
            direction.Normalize();
            var vx = speed * Mathf.Cos(angleRad);
            var vy = speed * Mathf.Sin(angleRad);

            var velocity = new Vector3(direction.x * vx, vy, direction.z * vx);
            return velocity;
        }

        private void PredictLine(Vector3 startPosition)
        {
            if (!isUsingPredictLine) return;

            UpdateLineRender(lineMaxPoint, (0, launchTransform.position));

            var currentVelocity = launchVelocity;
            var predictPosition = startPosition;
            for (var i = 0; i < lineMaxPoint; i++)
            {
                currentVelocity = GetNextPredictedPosition(currentVelocity, 0f, lineInterval);
                var nextPosition = predictPosition + currentVelocity * lineInterval;

                predictPosition = nextPosition;
                UpdateLineRender(lineMaxPoint, (i, predictPosition));
                
                if (Physics.Raycast(predictPosition - currentVelocity.normalized * lineInterval, currentVelocity.normalized, out var hit, cannonRadius * 2, hitLayer, QueryTriggerInteraction.Collide))
                {
                    UpdateLineRender(i + 1, (i, predictPosition));
                    
                    if (newHitMarker)
                    {
                        newHitMarker.transform.position = predictPosition;
                        var hitRotation = Quaternion.FromToRotation(Vector3.up, hit.normal);
                        newHitMarker.transform.rotation = Quaternion.Euler(90, 0, 0) * hitRotation;
                    }

                    return;
                }
            }
        }
        
        private Vector3 GetNextPredictedPosition(Vector3 currentVelocity, float drag, float increment)
        {
            currentVelocity += Physics.gravity * increment;
            currentVelocity *= Mathf.Clamp01(1f - drag * increment);
            return currentVelocity;
        }
        
        private void UpdateLineRender(int count, (int point, Vector3 pos) pointPos)
        {
            predictedLine.positionCount = count;
            predictedLine.SetPosition(pointPos.point, pointPos.pos);
        }
        
        private IEnumerator LaunchCoolDown(float waitTime)
        {
            var time = 0f;
            launchProcessBar.SetSliderValue(0f);
            launchProcessBar.SetActiveReloadSlider(true);

            while (time <= waitTime)
            {
                time += Time.deltaTime;
                var sliderValue = time > 0 ? time / waitTime : 0f;
                launchProcessBar.SetSliderValue(sliderValue);
                yield return null;
            }

            isReloading = false;
            launchProcessBar.SetActiveReloadSlider(false);
        }

        private void Launch()
        {
            VisualFeedbackManager.Inst.CameraShake(CameraManager.Inst.OceanCamera.BaseShipCam, cameraShakePower, cameraShakeDuration);
            var projectile = Instantiate(projectileObject, launchTransform.position, Quaternion.identity);
            var particleWeapon = projectile.GetComponent<ParticleWeapon>();
            particleWeapon.SetHitMarker(newHitMarker);
            particleWeapon.onHitAction.AddListener(HitAction);
            particleWeapon.Rb.AddForce(launchVelocity, ForceMode.VelocityChange);
            
            isReloading = true;
        }
        
        private void HitAction(RaycastHit hit, float power, GameObject marker = null)
        {
            if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Water"))
            {
                var maxSize = Physics.OverlapSphereNonAlloc(hit.point, cannonRadius, hitColliders, boidsLayer,
                    QueryTriggerInteraction.Collide);

                for (var i = 0; i < maxSize; i++)
                {
                    var hitBoids = hitColliders[i].GetComponentInParent<Boids>();
                    var catchSize = Random.Range((int)randomCatch.x, (int)randomCatch.y + 1);
                    hitBoids.CatchBoid(hitColliders[i], catchSize);
                }
            }
            else
            {
                hit.transform.GetComponent<IDamageable>()?.TakeDamage(power);
            }

            if (marker)
            {
                Destroy(marker);
            }
        }
        
        #endregion
    }
}